Scikit Learn - Convenções

Os objetos do Scikit-learn compartilham uma API básica uniforme que consiste nas três interfaces complementares a seguir -

Estimator interface - É para construir e ajustar os modelos.
Predictor interface - É para fazer previsões.
Transformer interface - É para converter dados.

As APIs adotam convenções simples e as escolhas de design foram guiadas de maneira a evitar a proliferação de código de estrutura.

Objetivo das Convenções

O objetivo das convenções é garantir que a API siga os seguintes princípios gerais -

Consistency - Todos os objetos, sejam eles básicos ou compostos, devem compartilhar uma interface consistente que é composta por um conjunto limitado de métodos.

Inspection - Os parâmetros do construtor e os valores dos parâmetros determinados pelo algoritmo de aprendizagem devem ser armazenados e expostos como atributos públicos.

Non-proliferation of classes - Os conjuntos de dados devem ser representados como matrizes NumPy ou matriz esparsa Scipy, enquanto os nomes e valores de hiperparâmetros devem ser representados como strings Python padrão para evitar a proliferação de código de estrutura.

Composition - Os algoritmos, quer sejam expressos como sequências ou combinações de transformações dos dados ou naturalmente vistos como meta-algoritmos parametrizados em outros algoritmos, devem ser implementados e compostos a partir de blocos de construção existentes.

Sensible defaults- No scikit-learn, sempre que uma operação requer um parâmetro definido pelo usuário, um valor padrão apropriado é definido. Este valor padrão deve fazer com que a operação seja executada de forma sensata, por exemplo, fornecendo uma solução de linha de base para a tarefa em questão.

Várias Convenções

As convenções disponíveis no Sklearn são explicadas abaixo -

Fundição de tipo

Ele afirma que a entrada deve ser convertida para float64. No exemplo a seguir, em quesklearn.random_projection módulo usado para reduzir a dimensionalidade dos dados, irá explicá-lo -

Example

import numpy as np
from sklearn import random_projection
rannge = np.random.RandomState(0)
X = range.rand(10,2000)
X = np.array(X, dtype = 'float32')
X.dtype
Transformer_data = random_projection.GaussianRandomProjection()
X_new = transformer.fit_transform(X)
X_new.dtype

Output

dtype('float32')
dtype('float64')

No exemplo acima, podemos ver que X é float32 que é lançado para float64 de fit_transform(X).

Parâmetros de reajuste e atualização

Os hiperparâmetros de um estimador podem ser atualizados e reajustados após ter sido construído por meio do set_params()método. Vamos ver o seguinte exemplo para entender isso -

Example

import numpy as np
from sklearn.datasets import load_iris
from sklearn.svm import SVC
X, y = load_iris(return_X_y = True)
clf = SVC()
clf.set_params(kernel = 'linear').fit(X, y)
clf.predict(X[:5])

Output

array([0, 0, 0, 0, 0])

Uma vez que o estimador foi construído, o código acima mudará o kernel padrão rbf para linear via SVC.set_params().

Agora, o código a seguir mudará de volta o kernel para rbf para reajustar o estimador e fazer uma segunda previsão.

Example

clf.set_params(kernel = 'rbf', gamma = 'scale').fit(X, y)
clf.predict(X[:5])

Output

array([0, 0, 0, 0, 0])

Código completo

A seguir está o programa executável completo -

import numpy as np
from sklearn.datasets import load_iris
from sklearn.svm import SVC
X, y = load_iris(return_X_y = True)
clf = SVC()
clf.set_params(kernel = 'linear').fit(X, y)
clf.predict(X[:5])
clf.set_params(kernel = 'rbf', gamma = 'scale').fit(X, y)
clf.predict(X[:5])

Adaptação multiclasse e etiqueta múltipla

No caso de ajuste de várias classes, tanto as tarefas de aprendizado quanto as de previsão dependem do formato dos dados do alvo ajustados. O módulo usado ésklearn.multiclass. Verifique o exemplo abaixo, onde o classificador multiclasse se ajusta a uma matriz 1d.

Example

from sklearn.svm import SVC
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import LabelBinarizer
X = [[1, 2], [3, 4], [4, 5], [5, 2], [1, 1]]
y = [0, 0, 1, 1, 2]
classif = OneVsRestClassifier(estimator = SVC(gamma = 'scale',random_state = 0))
classif.fit(X, y).predict(X)

Output

array([0, 0, 1, 1, 2])

No exemplo acima, o classificador é ajustado em uma matriz dimensional de rótulos multiclasse e o predict()método, portanto, fornece previsão multiclasse correspondente. Mas, por outro lado, também é possível ajustar em uma matriz bidimensional de indicadores de rótulo binários da seguinte maneira -

Example

from sklearn.svm import SVC
from sklearn.multiclass import OneVsRestClassifier
from sklearn.preprocessing import LabelBinarizer
X = [[1, 2], [3, 4], [4, 5], [5, 2], [1, 1]]
y = LabelBinarizer().fit_transform(y)
classif.fit(X, y).predict(X)

Output

array(
   [
      [0, 0, 0],
      [0, 0, 0],
      [0, 1, 0],
      [0, 1, 0],
      [0, 0, 0]
   ]
)

Da mesma forma, no caso de ajuste de múltiplas etiquetas, uma instância pode receber várias etiquetas da seguinte forma -

Example

from sklearn.preprocessing import MultiLabelBinarizer
y = [[0, 1], [0, 2], [1, 3], [0, 2, 3], [2, 4]]
y = MultiLabelBinarizer().fit_transform(y)
classif.fit(X, y).predict(X)

Output

array(
   [
      [1, 0, 1, 0, 0],
      [1, 0, 1, 0, 0],
      [1, 0, 1, 1, 0],
      [1, 0, 1, 1, 0],
      [1, 0, 1, 0, 0]
   ]
)

No exemplo acima, sklearn.MultiLabelBinarizeré usado para binarizar a matriz bidimensional de rótulos múltiplos para ajustar. É por isso que a função predict () fornece uma matriz 2d como saída com vários rótulos para cada instância.