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);