Machine learning lida com problemas que envolvem aprendizagem. Existe uma ampla gama de algoritmos de machine learning. Muitos são de fácil implementação. Outros são mais complexos. Felizmente, no entanto, o Python conta com inúmeras e excelentes bibliotecas para implementações de machine learning de forma fácil e descomplicada. A biblioteca scikit-learn é uma das principais para isso.
Neste post, faremos uma breve introdução à biblioteca scikit-learn, descrevendo como ela pode ser utilizada.
Pré-requisitos
- Um computador com Python 3
- scikit-learn
- matplotlib para visualização
Para instalar o scikit-learn com pip:
pip install -U scikit-learn
Para instalar com conda:
conda install -c anaconda scikit-learn
Instalação do matplotlib:
python -m pip install -U pip
python -m pip install -U matplotlib
Para instalar o matplotlib com conda:
conda install -c conda-forge matplotlib
Procedimentos
Como explicamos anteriormente, implementações de machine learning envolvem certos elementos comuns. Eles são: obtenção e preparação dos dados, definição do algoritmo que será usado, treinamento, avaliação do modelo e realização de previsões. Neste post, iremos utilizar o scikit-learn para ilustrar a execução destes elementos.
Explicação sobre os dados
Para esse post, vamos utilizar um conjunto de dados que a biblioteca scikit-learn já possui.
Existem vários conjuntos disponíveis. Iremos usar o conjunto digits, apropriado para classificação com aprendizagem supervisionada.
Os dados desse conjunto consistem em imagens de dígitos (0-9) escritos a mão e classificadas nas 10 classes correspondentes.
O objetivo dos algoritmos de machine learning numa tarefa de aprendizagem supervisionada com esse tipo de dado é aprender a mapear as imagens com os nomes dos números correspondentes (0-9). Após a aprendizagem, um algoritmo treinado deve ser capaz de classificar corretamente imagens inéditas de dígitos.
O conjunto de dados digit contém imagens de 8 x 8 pixéis (baixíssima resolução) em escala de cinzas. Ele tem um membro .image com as imagens dos dígitos e um membro .target com as classes corretas atribuídas a cada imagem.
Primeiro, para iniciar nosso código, vamos importar as bibliotecas necessárias e carregar os dados para verificar suas dimensões.
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn import datasets, metrics, svm
from sklearn.model_selection import train_test_split
digits = datasets.load_digits()
print(digits.images.shape)
A execução do código mostra que os dados contêm 1797 imagens com dimensões de 8 x 8.
(1797, 8, 8)
Visualização dos dados
Em seguida, vamos visualizar algumas dessas imagens com o matplotlib. Digite o código abaixo para plotar as 5 primeiras imagens presentes no conjunto digits com as classificações correspondentes.
_, axes = plt.subplots(nrows=1, ncols=5, figsize=(15, 3))
for ax, image, label in zip(axes, digits.images, digits.target):
ax.set_axis_off()
ax.imshow(image, cmap=plt.cm.gray_r, interpolation="nearest")
ax.set_title(f"Training: {label}")
plt.show()
Executando o código, ele plota uma figura como a mostrada abaixo. No alto de cada imagem, está escrito o nome de sua classe. Note que são imagens de baixíssima resolução.
Preparação dos dados
Para problemas de machine learning, a fase de preparação dos dados é essencial. No caso do nosso exemplo, ela consiste em transformar cada imagem em um arranjo unidimensional:
n_amostras = len(digits.images)
dados = digits.images.reshape((n_amostras, -1))
print(dados.shape)
A execução do código acima indica que nosso arquivo de dados contém agora 1797 exemplos com 64 atributos cada.
(1797, 64)
Criação dos conjuntos de treinamento e teste
Implementações de machine learning envolvem uma fase de aprendizagem de algumas propriedades de um conjunto de dados e, em seguida, a verificação dessas propriedades em dados inéditos.
Uma prática comum é avaliar um algoritmo dividindo um conjunto de dados em dois, um para a fase de treinamento e outro para a fase de teste. A biblioteca scikit-learn tem funcionalidades que facilitam essa tarefa. No código abaixo, os dados do conjunto digit serão divididos. Metade deles será usada como conjunto de treinamento e a outra metade será o conjunto de teste.
X_treino, X_teste, y_treino, y_teste = train_test_split(
dados, digits.target, test_size=0.5, shuffle=False
)
Classificação e verificação do desempenho do algoritmo
Em seguida, a classificação pode ser feita com um algoritmo escolhido entre os vários que a biblioteca scikit-learn possui. Para esse exemplo, iremos usar um classificador com vetor de suporte (supported vector classifier, SVC).
clf = svm.SVC(gamma=0.001)
Após a seleção do classificador, é preciso definir o processo de treino como mostrado abaixo.
clf.fit(X_treino, y_treino)
Na sequência, é preciso verificar o desempenho do nosso classificador treinado no conjunto de testes.
predicted = clf.predict(X_teste)
Os dados da predição podem ser usados para a criação de um pequeno relatório:
print(
f"Relatório de classificação do classificador {clf}:\n"
f"{metrics.classification_report(y_teste, predicted)}\n"
)
Executando o código completo, o relatório mostra a acurácia do algoritmo treinado.
Relatório de classificação do classificador SVC(gamma=0.001):
precision recall f1-score support
0 1.00 0.99 0.99 88
1 0.99 0.97 0.98 91
2 0.99 0.99 0.99 86
3 0.98 0.87 0.92 91
4 0.99 0.96 0.97 92
5 0.95 0.97 0.96 91
6 0.99 0.99 0.99 91
7 0.96 0.99 0.97 89
8 0.94 1.00 0.97 88
9 0.93 0.98 0.95 92
accuracy 0.97 899
macro avg 0.97 0.97 0.97 899
weighted avg 0.97 0.97 0.97 899
Para terminar, vamos plotar mais alguns exemplos de dígitos, mas agora com a classificação atribuída pelo algoritmo treinado.
_, axes = plt.subplots(nrows=1, ncols=5, figsize=(15, 3))
for ax, image, prediction in zip(axes, X_teste, predicted):
ax.set_axis_off()
image = image.reshape(8, 8)
ax.imshow(image, cmap=plt.cm.gray_r, interpolation="nearest")
ax.set_title(f"Prediction: {prediction}")
plt.show()
Execute o código e veja se a classe atribuída corresponde a cada imagem mostrada na figura. A figura obtida é mostrada abaixo.
Conclusão
Nesse post, apresentamos uma breve introdução a biblioteca scikit-learn para ilustrar com ela pode ser usada para implementações de machine learning de forma simples e rápida. Se você tem interesse em aprender mais, visite o site oficial e explore os outros conjuntos de dados e algoritmos que a biblioteca possui.
Referência
Essa postagem foi baseada no material disponível no site oficial.
O código completo deste post é mostrado abaixo.
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn import datasets, metrics, svm
from sklearn.model_selection import train_test_split
# carrega dados
digits = datasets.load_digits()
print(digits.images.shape)
# plota 1a fig
_, axes = plt.subplots(nrows=1, ncols=5, figsize=(15, 3))
for ax, image, label in zip(axes, digits.images, digits.target):
ax.set_axis_off()
ax.imshow(image, cmap=plt.cm.gray_r, interpolation="nearest")
ax.set_title(f"Training: {label}")
plt.show()
# reshape
n_amostras = len(digits.images)
dados = digits.images.reshape((n_amostras, -1))
print(dados.shape)
# criação do conjunto de treinamento e do conjunto de teste
X_treino, X_teste, y_treino, y_teste = train_test_split(
dados, digits.target, test_size=0.5, shuffle=False
)
# definição do classificador
clf = svm.SVC(gamma=0.001)
# treinamento
clf.fit(X_treino, y_treino)
# verificação de desempenho
predicted = clf.predict(X_teste)
# relatório de desempenho
print(
f"Relatório de classificação do classificador {clf}:\n"
f"{metrics.classification_report(y_teste, predicted)}\n"
)
# 2a fig
_, axes = plt.subplots(nrows=1, ncols=5, figsize=(15, 3))
for ax, image, prediction in zip(axes, X_teste, predicted):
ax.set_axis_off()
image = image.reshape(8, 8)
ax.imshow(image, cmap=plt.cm.gray_r, interpolation="nearest")
ax.set_title(f"Prediction: {prediction}")
plt.show()
