Scikit Learn - Processo de Modelagem

Este capítulo trata do processo de modelagem envolvido no Sklearn. Vamos entender o mesmo em detalhes e começar com o carregamento do conjunto de dados.

Carregando o conjunto de dados

Uma coleção de dados é chamada de conjunto de dados. Ele tem os dois componentes a seguir -

Features- As variáveis ​​de dados são chamadas de seus recursos. Eles também são conhecidos como preditores, entradas ou atributos.

  • Feature matrix - É a coleção de recursos, caso haja mais de um.

  • Feature Names - É a lista de todos os nomes dos recursos.

Response- É a variável de saída que depende basicamente das variáveis ​​de recursos. Eles também são conhecidos como destino, rótulo ou saída.

  • Response Vector- É usado para representar a coluna de resposta. Geralmente, temos apenas uma coluna de resposta.

  • Target Names - Representa os valores possíveis assumidos por um vetor de resposta.

Scikit-learn tem alguns exemplos de conjuntos de dados como iris e digits para classificação e o Boston house prices para regressão.

Exemplo

A seguir está um exemplo para carregar iris conjunto de dados -

from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
feature_names = iris.feature_names
target_names = iris.target_names
print("Feature names:", feature_names)
print("Target names:", target_names)
print("\nFirst 10 rows of X:\n", X[:10])

Resultado

Feature names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
Target names: ['setosa' 'versicolor' 'virginica']
First 10 rows of X:
[
   [5.1 3.5 1.4 0.2]
   [4.9 3. 1.4 0.2]
   [4.7 3.2 1.3 0.2]
   [4.6 3.1 1.5 0.2]
   [5. 3.6 1.4 0.2]
   [5.4 3.9 1.7 0.4]
   [4.6 3.4 1.4 0.3]
   [5. 3.4 1.5 0.2]
   [4.4 2.9 1.4 0.2]
   [4.9 3.1 1.5 0.1]
]

Dividindo o conjunto de dados

Para verificar a precisão do nosso modelo, podemos dividir o conjunto de dados em duas partes-a training set e a testing set. Use o conjunto de treinamento para treinar o modelo e o conjunto de teste para testar o modelo. Depois disso, podemos avaliar o desempenho do nosso modelo.

Exemplo

O exemplo a seguir dividirá os dados na proporção de 70:30, ou seja, 70% dos dados serão usados ​​como dados de treinamento e 30% como dados de teste. O conjunto de dados é um conjunto de dados da íris como no exemplo acima.

from sklearn.datasets import load_iris
iris = load_iris()

X = iris.data
y = iris.target

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
   X, y, test_size = 0.3, random_state = 1
)

print(X_train.shape)
print(X_test.shape)

print(y_train.shape)
print(y_test.shape)

Resultado

(105, 4)
(45, 4)
(105,)
(45,)

Como visto no exemplo acima, ele usa train_test_split()função do scikit-learn para dividir o conjunto de dados. Esta função tem os seguintes argumentos -

  • X, y - Aqui, X é o feature matrix e y é o response vector, que precisa ser dividido.

  • test_size- Isso representa a proporção dos dados de teste em relação ao total de dados fornecidos. Como no exemplo acima, estamos definindotest_data = 0.3 para 150 linhas de X. Ele produzirá dados de teste de 150 * 0,3 = 45 linhas.

  • random_size- É utilizado para garantir que a divisão será sempre a mesma. Isso é útil nas situações em que você deseja resultados reproduzíveis.

Treine o modelo

Em seguida, podemos usar nosso conjunto de dados para treinar algum modelo de previsão. Conforme discutido, o scikit-learn tem uma ampla gama deMachine Learning (ML) algorithms que têm uma interface consistente para ajuste, previsão de precisão, recall etc.

Exemplo

No exemplo abaixo, vamos usar o classificador KNN (K vizinhos mais próximos). Não entre em detalhes sobre algoritmos KNN, pois haverá um capítulo separado para isso. Este exemplo é usado para fazer você entender apenas a parte de implementação.

from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
   X, y, test_size = 0.4, random_state=1
)
from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
classifier_knn = KNeighborsClassifier(n_neighbors = 3)
classifier_knn.fit(X_train, y_train)
y_pred = classifier_knn.predict(X_test)
# Finding accuracy by comparing actual response values(y_test)with predicted response value(y_pred)
print("Accuracy:", metrics.accuracy_score(y_test, y_pred))
# Providing sample data and the model will make prediction out of that data

sample = [[5, 5, 3, 2], [2, 4, 3, 5]]
preds = classifier_knn.predict(sample)
pred_species = [iris.target_names[p] for p in preds] print("Predictions:", pred_species)

Resultado

Accuracy: 0.9833333333333333
Predictions: ['versicolor', 'virginica']

Persistência do modelo

Depois de treinar o modelo, é desejável que ele seja persistente para uso futuro, para que não seja necessário treiná-lo novamente. Isso pode ser feito com a ajuda dedump e load características de joblib pacote.

Considere o exemplo abaixo no qual estaremos salvando o modelo treinado acima (classifier_knn) para uso futuro -

from sklearn.externals import joblib
joblib.dump(classifier_knn, 'iris_classifier_knn.joblib')

O código acima salvará o modelo em um arquivo denominado iris_classifier_knn.joblib. Agora, o objeto pode ser recarregado do arquivo com a ajuda do seguinte código -

joblib.load('iris_classifier_knn.joblib')

Pré-processamento dos dados

Como estamos lidando com muitos dados e esses dados estão na forma bruta, antes de inserir esses dados em algoritmos de aprendizado de máquina, precisamos convertê-los em dados significativos. Esse processo é chamado de pré-processamento dos dados. Scikit-learn tem um pacote chamadopreprocessingpara este propósito. opreprocessing pacote tem as seguintes técnicas -

Binarização

Essa técnica de pré-processamento é usada quando precisamos converter nossos valores numéricos em valores booleanos.

Exemplo

import numpy as np
from sklearn import preprocessing
Input_data = np.array(
   [2.1, -1.9, 5.5],
   [-1.5, 2.4, 3.5],
   [0.5, -7.9, 5.6],
   [5.9, 2.3, -5.8]]
)
data_binarized = preprocessing.Binarizer(threshold=0.5).transform(input_data)
print("\nBinarized data:\n", data_binarized)

No exemplo acima, usamos threshold value = 0,5 e é por isso que todos os valores acima de 0,5 seriam convertidos em 1 e todos os valores abaixo de 0,5 seriam convertidos em 0.

Resultado

Binarized data:
[
   [ 1. 0. 1.]
   [ 0. 1. 1.]
   [ 0. 0. 1.]
   [ 1. 1. 0.]
]

Remoção Média

Esta técnica é usada para eliminar a média do vetor de recurso de forma que cada recurso seja centralizado em zero.

Exemplo

import numpy as np
from sklearn import preprocessing
Input_data = np.array(
   [2.1, -1.9, 5.5],
   [-1.5, 2.4, 3.5],
   [0.5, -7.9, 5.6],
   [5.9, 2.3, -5.8]]
)

#displaying the mean and the standard deviation of the input data
print("Mean =", input_data.mean(axis=0))
print("Stddeviation = ", input_data.std(axis=0))
#Removing the mean and the standard deviation of the input data

data_scaled = preprocessing.scale(input_data)
print("Mean_removed =", data_scaled.mean(axis=0))
print("Stddeviation_removed =", data_scaled.std(axis=0))

Resultado

Mean = [ 1.75 -1.275 2.2 ]
Stddeviation = [ 2.71431391 4.20022321 4.69414529]
Mean_removed = [ 1.11022302e-16 0.00000000e+00 0.00000000e+00]
Stddeviation_removed = [ 1. 1. 1.]

Dimensionamento

Usamos essa técnica de pré-processamento para dimensionar os vetores de recursos. O dimensionamento dos vetores de recursos é importante, porque os recursos não devem ser sinteticamente grandes ou pequenos.

Exemplo

import numpy as np
from sklearn import preprocessing
Input_data = np.array(
   [
      [2.1, -1.9, 5.5],
      [-1.5, 2.4, 3.5],
      [0.5, -7.9, 5.6],
      [5.9, 2.3, -5.8]
   ]
)
data_scaler_minmax = preprocessing.MinMaxScaler(feature_range=(0,1))
data_scaled_minmax = data_scaler_minmax.fit_transform(input_data)
print ("\nMin max scaled data:\n", data_scaled_minmax)

Resultado

Min max scaled data:
[
   [ 0.48648649 0.58252427 0.99122807]
   [ 0. 1. 0.81578947]
   [ 0.27027027 0. 1. ]
   [ 1. 0.99029126 0. ]
]

Normalização

Usamos essa técnica de pré-processamento para modificar os vetores de recursos. A normalização dos vetores de recursos é necessária para que os vetores de recursos possam ser medidos em uma escala comum. Existem dois tipos de normalização, como segue -

Normalização L1

É também chamado de Desvios Mínimos Absolutos. Modifica o valor de forma que a soma dos valores absolutos permaneça sempre até 1 em cada linha. O exemplo a seguir mostra a implementação da normalização L1 nos dados de entrada.

Exemplo

import numpy as np
from sklearn import preprocessing
Input_data = np.array(
   [
      [2.1, -1.9, 5.5],
      [-1.5, 2.4, 3.5],
      [0.5, -7.9, 5.6],
      [5.9, 2.3, -5.8]
   ]
)
data_normalized_l1 = preprocessing.normalize(input_data, norm='l1')
print("\nL1 normalized data:\n", data_normalized_l1)

Resultado

L1 normalized data:
[
   [ 0.22105263 -0.2 0.57894737]
   [-0.2027027 0.32432432 0.47297297]
   [ 0.03571429 -0.56428571 0.4 ]
   [ 0.42142857 0.16428571 -0.41428571]
]

Normalização L2

Também chamado de Least Squares. Modifica o valor de forma que a soma dos quadrados permaneça sempre até 1 em cada linha. O exemplo a seguir mostra a implementação da normalização L2 nos dados de entrada.

Exemplo

import numpy as np
from sklearn import preprocessing
Input_data = np.array(
   [
      [2.1, -1.9, 5.5],
      [-1.5, 2.4, 3.5],
      [0.5, -7.9, 5.6],
      [5.9, 2.3, -5.8]
   ]
)
data_normalized_l2 = preprocessing.normalize(input_data, norm='l2')
print("\nL1 normalized data:\n", data_normalized_l2)

Resultado

L2 normalized data:
[
   [ 0.33946114 -0.30713151 0.88906489]
   [-0.33325106 0.53320169 0.7775858 ]
   [ 0.05156558 -0.81473612 0.57753446]
   [ 0.68706914 0.26784051 -0.6754239 ]
]