Scikit Learn - Convenzioni

Gli oggetti di Scikit-learn condividono un'API di base uniforme che consiste nelle seguenti tre interfacce complementari:

• Estimator interface - Serve per costruire e adattare i modelli.

• Predictor interface - Serve per fare previsioni.

• Transformer interface - Serve per convertire i dati.

Le API adottano convenzioni semplici e le scelte di progettazione sono state guidate in modo da evitare la proliferazione del codice del framework.

Scopo delle convenzioni

Lo scopo delle convenzioni è assicurarsi che l'API si attenga ai seguenti principi generali:

Consistency - Tutti gli oggetti, siano essi di base o compositi, devono condividere un'interfaccia coerente composta ulteriormente da un insieme limitato di metodi.

Inspection - I parametri del costruttore e i valori dei parametri determinati dall'algoritmo di apprendimento devono essere memorizzati ed esposti come attributi pubblici.

Non-proliferation of classes - I set di dati dovrebbero essere rappresentati come array NumPy o matrice sparsa Scipy mentre i nomi ei valori degli iperparametri dovrebbero essere rappresentati come stringhe Python standard per evitare la proliferazione del codice del framework.

Composition - Gli algoritmi, sia che siano esprimibili come sequenze o combinazioni di trasformazioni ai dati, sia che siano naturalmente visti come meta-algoritmi parametrizzati su altri algoritmi, dovrebbero essere implementati e composti da blocchi di costruzione esistenti.

Sensible defaults- In scikit-learn ogni volta che un'operazione richiede un parametro definito dall'utente, viene definito un valore predefinito appropriato. Questo valore predefinito dovrebbe far sì che l'operazione venga eseguita in modo ragionevole, ad esempio, fornendo una soluzione di base per l'attività in corso.

Convenzioni varie

Le convenzioni disponibili in Sklearn sono spiegate di seguito:

Digitare casting

Dichiara che l'input deve essere convertito in float64. Nell'esempio seguente, in cuisklearn.random_projection modulo utilizzato per ridurre la dimensionalità dei dati, lo spiegherà -

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

Nell'esempio sopra, possiamo vedere che X è float32 a cui viene lanciato float64 di fit_transform(X).

Refitting e aggiornamento dei parametri

Gli iperparametri di uno stimatore possono essere aggiornati e rimontati dopo che è stato costruito tramite set_params()metodo. Vediamo il seguente esempio per capirlo:

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

Una volta che lo stimatore è stato costruito, il codice sopra cambierà il kernel predefinito rbf a lineare via SVC.set_params().

Ora, il codice seguente cambierà di nuovo il kernel in rbf per rimontare lo stimatore e per fare una seconda previsione.

Example

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

Output

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

Codice completo

Quello che segue è il programma eseguibile 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])

Adattamento Multiclass e Multilabel

In caso di adattamento multiclasse, sia l'apprendimento che le attività di previsione dipendono dal formato dei dati target su cui si adattano. Il modulo utilizzato èsklearn.multiclass. Controlla l'esempio seguente, dove il classificatore multiclasse si adatta a un array 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])

Nell'esempio precedente, il classificatore si adatta a una matrice unidimensionale di etichette multiclasse e l'estensione predict()quindi fornisce la previsione multiclasse corrispondente. Ma d'altra parte, è anche possibile adattare una matrice bidimensionale di indicatori di etichette binarie come segue:

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

Allo stesso modo, in caso di adattamento di più etichette, a un'istanza possono essere assegnate più etichette come segue:

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

Nell'esempio sopra, sklearn.MultiLabelBinarizerè usato per binarizzare la matrice bidimensionale di multilabel su cui adattarsi. Ecco perché la funzione predice () fornisce un array 2d come output con più etichette per ogni istanza.