Scikit Learn - API Estimator
Neste capítulo, aprenderemos sobre Estimator API(interface de programação de aplicativo). Vamos começar entendendo o que é uma API Estimator.
O que é API Estimator
É uma das principais APIs implementadas pelo Scikit-learn. Ele fornece uma interface consistente para uma ampla gama de aplicativos de ML, por isso todos os algoritmos de aprendizado de máquina no Scikit-Learn são implementados por meio da API Estimator. O objeto que aprende com os dados (ajustando os dados) é um estimador. Pode ser usado com qualquer um dos algoritmos como classificação, regressão, clustering ou mesmo com um transformador, que extrai recursos úteis de dados brutos.
Para ajustar os dados, todos os objetos estimadores expõem um método de ajuste que leva um conjunto de dados mostrado a seguir -
estimator.fit(data)
A seguir, todos os parâmetros de um estimador podem ser definidos, da seguinte maneira, quando ele é instanciado pelo atributo correspondente.
estimator = Estimator (param1=1, param2=2)
estimator.param1
A saída do acima seria 1.
Uma vez que os dados são ajustados com um estimador, os parâmetros são estimados a partir dos dados disponíveis. Agora, todos os parâmetros estimados serão os atributos do objeto estimador terminando por um sublinhado da seguinte forma -
estimator.estimated_param_
Uso da API Estimator
Os principais usos dos estimadores são os seguintes -
Estimativa e decodificação de um modelo
O objeto Estimador é usado para estimativa e decodificação de um modelo. Além disso, o modelo é estimado como uma função determinística do seguinte -
Os parâmetros fornecidos na construção do objeto.
O estado aleatório global (numpy.random) se o parâmetro random_state do estimador for definido como nenhum.
Quaisquer dados passados para a chamada mais recente para fit, fit_transform, or fit_predict.
Quaisquer dados passados em uma sequência de chamadas para partial_fit.
Mapeamento de representação de dados não retangulares em dados retangulares
Ele mapeia uma representação de dados não retangular em dados retangulares. Em palavras simples, é necessária uma entrada onde cada amostra não é representada como um objeto semelhante a uma matriz de comprimento fixo e produz um objeto semelhante a uma matriz de características para cada amostra.
Distinção entre amostras centrais e periféricas
Ele modela a distinção entre amostras centrais e periféricas usando os seguintes métodos -
fit
fit_predict se transdutivo
prever se indutivo
Princípios Orientadores
Ao projetar a API Scikit-Learn, seguindo os princípios orientadores mantidos em mente -
Consistência
Este princípio afirma que todos os objetos devem compartilhar uma interface comum desenhada a partir de um conjunto limitado de métodos. A documentação também deve ser consistente.
Hierarquia limitada de objetos
Este princípio orientador diz -
Algoritmos devem ser representados por classes Python
Os conjuntos de dados devem ser representados no formato padrão como matrizes NumPy, Pandas DataFrames, matriz esparsa SciPy.
Os nomes dos parâmetros devem usar strings Python padrão.
Composição
Como sabemos, os algoritmos de ML podem ser expressos como a sequência de muitos algoritmos fundamentais. O Scikit-learn usa esses algoritmos fundamentais sempre que necessário.
Padrões sensatos
De acordo com esse princípio, a biblioteca Scikit-learn define um valor padrão apropriado sempre que os modelos de ML exigem parâmetros especificados pelo usuário.
Inspeção
De acordo com este princípio orientador, cada valor de parâmetro especificado é exposto como atributos públicos.
Etapas no uso da API Estimator
A seguir estão as etapas de uso da API do estimador Scikit-Learn -
Etapa 1: Escolha uma classe de modelo
Nesta primeira etapa, precisamos escolher uma classe de modelo. Isso pode ser feito importando a classe Estimator apropriada do Scikit-learn.
Etapa 2: escolha os hiperparâmetros do modelo
Nesta etapa, precisamos escolher hiperparâmetros do modelo de classe. Isso pode ser feito instanciando a classe com os valores desejados.
Etapa 3: Organizando os dados
Em seguida, precisamos organizar os dados em matriz de características (X) e vetor de destino (y).
Etapa 4: ajuste do modelo
Agora, precisamos ajustar o modelo aos seus dados. Isso pode ser feito chamando o método fit () da instância do modelo.
Etapa 5: Aplicar o modelo
Depois de ajustar o modelo, podemos aplicá-lo a novos dados. Para aprendizagem supervisionada, usepredict()método para prever os rótulos de dados desconhecidos. Enquanto para aprendizagem não supervisionada, usepredict() ou transform() para inferir propriedades dos dados.
Exemplo de aprendizagem supervisionada
Aqui, como exemplo deste processo, estamos tomando o caso comum de ajustar uma linha aos dados (x, y), ou seja simple linear regression.
Primeiro, precisamos carregar o conjunto de dados, estamos usando o conjunto de dados iris -
Exemplo
import seaborn as sns
iris = sns.load_dataset('iris')
X_iris = iris.drop('species', axis = 1)
X_iris.shape
Resultado
(150, 4)
Exemplo
y_iris = iris['species']
y_iris.shape
Resultado
(150,)
Exemplo
Agora, para este exemplo de regressão, vamos usar os seguintes dados de amostra -
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.RandomState(35)
x = 10*rng.rand(40)
y = 2*x-1+rng.randn(40)
plt.scatter(x,y);
Resultado
Portanto, temos os dados acima para nosso exemplo de regressão linear.
Agora, com esses dados, podemos aplicar as etapas acima mencionadas.
Escolha uma classe de modelo
Aqui, para calcular um modelo de regressão linear simples, precisamos importar a classe de regressão linear da seguinte forma -
from sklearn.linear_model import LinearRegression
Escolha os hiperparâmetros do modelo
Depois de escolher uma classe de modelo, precisamos fazer algumas escolhas importantes, que geralmente são representadas como hiperparâmetros ou os parâmetros que devem ser definidos antes que o modelo seja ajustado aos dados. Aqui, para este exemplo de regressão linear, gostaríamos de ajustar a interceptação usando ofit_intercept hiperparâmetro da seguinte forma -
Example
model = LinearRegression(fit_intercept = True)
model
Output
LinearRegression(copy_X = True, fit_intercept = True, n_jobs = None, normalize = False)
Organizando os dados
Agora, como sabemos que nossa variável alvo y está na forma correta, ou seja, um comprimento n_samplesmatriz de 1-D. Mas, precisamos remodelar a matriz de recursosX para torná-lo uma matriz de tamanho [n_samples, n_features]. Isso pode ser feito da seguinte forma -
Example
X = x[:, np.newaxis]
X.shape
Output
(40, 1)
Ajuste do modelo
Depois de organizar os dados, é hora de ajustar o modelo, ou seja, aplicar nosso modelo aos dados. Isso pode ser feito com a ajuda defit() método da seguinte forma -
Example
model.fit(X, y)
Output
LinearRegression(copy_X = True, fit_intercept = True, n_jobs = None,normalize = False)
No Scikit-learn, o fit() processo tem alguns sublinhados à direita.
Para este exemplo, o parâmetro abaixo mostra a inclinação do ajuste linear simples dos dados -
Example
model.coef_
Output
array([1.99839352])
O parâmetro abaixo representa a interceptação do ajuste linear simples aos dados -
Example
model.intercept_
Output
-0.9895459457775022
Aplicando o modelo a novos dados
Depois de treinar o modelo, podemos aplicá-lo a novos dados. Como a principal tarefa do aprendizado de máquina supervisionado é avaliar o modelo com base em novos dados que não fazem parte do conjunto de treinamento. Isso pode ser feito com a ajuda depredict() método da seguinte forma -
Example
xfit = np.linspace(-1, 11)
Xfit = xfit[:, np.newaxis]
yfit = model.predict(Xfit)
plt.scatter(x, y)
plt.plot(xfit, yfit);
Output
Exemplo completo de trabalho / executável
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
iris = sns.load_dataset('iris')
X_iris = iris.drop('species', axis = 1)
X_iris.shape
y_iris = iris['species']
y_iris.shape
rng = np.random.RandomState(35)
x = 10*rng.rand(40)
y = 2*x-1+rng.randn(40)
plt.scatter(x,y);
from sklearn.linear_model import LinearRegression
model = LinearRegression(fit_intercept=True)
model
X = x[:, np.newaxis]
X.shape
model.fit(X, y)
model.coef_
model.intercept_
xfit = np.linspace(-1, 11)
Xfit = xfit[:, np.newaxis]
yfit = model.predict(Xfit)
plt.scatter(x, y)
plt.plot(xfit, yfit);
Exemplo de aprendizado não supervisionado
Aqui, como exemplo desse processo, estamos tomando um caso comum de redução da dimensionalidade do conjunto de dados Iris para que possamos visualizá-lo com mais facilidade. Para este exemplo, vamos usar a análise de componentes principais (PCA), uma técnica de redução de dimensionalidade linear rápida.
Como no exemplo acima, podemos carregar e plotar os dados aleatórios do conjunto de dados da íris. Depois disso, podemos seguir as etapas abaixo -
Escolha uma classe de modelo
from sklearn.decomposition import PCA
Escolha os hiperparâmetros do modelo
Example
model = PCA(n_components=2)
model
Output
PCA(copy = True, iterated_power = 'auto', n_components = 2, random_state = None,
svd_solver = 'auto', tol = 0.0, whiten = False)
Ajuste do modelo
Example
model.fit(X_iris)
Output
PCA(copy = True, iterated_power = 'auto', n_components = 2, random_state = None,
svd_solver = 'auto', tol = 0.0, whiten = False)
Transforme os dados em bidimensionais
Example
X_2D = model.transform(X_iris)
Agora, podemos plotar o resultado da seguinte maneira -
Output
iris['PCA1'] = X_2D[:, 0]
iris['PCA2'] = X_2D[:, 1]
sns.lmplot("PCA1", "PCA2", hue = 'species', data = iris, fit_reg = False);
Output
Exemplo completo de trabalho / executável
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
iris = sns.load_dataset('iris')
X_iris = iris.drop('species', axis = 1)
X_iris.shape
y_iris = iris['species']
y_iris.shape
rng = np.random.RandomState(35)
x = 10*rng.rand(40)
y = 2*x-1+rng.randn(40)
plt.scatter(x,y);
from sklearn.decomposition import PCA
model = PCA(n_components=2)
model
model.fit(X_iris)
X_2D = model.transform(X_iris)
iris['PCA1'] = X_2D[:, 0]
iris['PCA2'] = X_2D[:, 1]
sns.lmplot("PCA1", "PCA2", hue='species', data=iris, fit_reg=False);