Seu primeiro Projeto de Machine Learning em Python (Passo a Passo)

Machine Learning é um subgrupo da IA que utiliza técnicas estatísticas para dar aos computadores a habilidade de aprender com dados sem serem explicitamente programados.

Aqui você irá montar seu primeiro projeto de Machine Learning (Aprendizado de máquina) usando a linguagem Python.

O que veremos:

1. Utilização do Google Colab (aconselho pra quem tá iniciando).
2. Carregar um conjunto de dados e entender sua estrutura usando resumos estatísticos e visualização de dados.
3. Criar 6 modelos de aprendizado de máquina e escolher o melhor.

Se você é um iniciante em aprendizado de máquina e quer finalmente começar a usar o Python, este tutorial foi pensado em sua necessidade, vamos lá!

Como você inicia o aprendizado de máquina em Python?

A melhor maneira de aprender aprendizado de máquina é projetar e concluir pequenos projetos.

Iniciantes precisam de um projeto pequeno de ponta a ponta

Livros e cursos são frustrantes. Eles te dão muitas receitas e trechos, mas você nunca consegue ver como eles se encaixam.

Quando você está aplicando o aprendizado de máquina aos seus próprios conjuntos de dados, está trabalhando em um projeto.

Um projeto de aprendizado de máquina pode não ser linear, mas tem várias etapas bem conhecidas:

1. Definir problema.
2. Prepare dados.
3. Avaliar algoritmos.
4. Melhore os resultados.
5. Apresentar resultados.

A melhor maneira de realmente chegar a um acordo com uma nova plataforma ou ferramenta é trabalhar com um projeto de aprendizado de máquina de ponta a ponta e cobrir os principais passos. Ou seja, a partir do carregamento de dados, resumindo dados, avaliando algoritmos e fazendo algumas previsões.

Hello World em Machine Learning

O melhor projeto pequeno para começar em uma nova ferramenta é a classificação das flores da íris (por exemplo, o conjunto de dados da íris ).

Este é um bom projeto porque é bem compreendido na literatura.

• Atributos são numéricos, então você tem que descobrir como carregar e manipular dados.
• É um problema de classificação, permitindo que você pratique com talvez um tipo mais fácil de algoritmo de aprendizado supervisionado.
• É um problema de classificação de múltiplas classes (multi-nominal) que pode requerer algum manuseio especializado.
• Ele tem apenas 4 atributos e 150 linhas, o que significa que é pequeno e cabe facilmente na memória (e uma tela ou página A4).
• Todos os atributos numéricos estão nas mesmas unidades e na mesma escala, não requerendo nenhum dimensionamento especial ou transformações para começar.

Vamos começar com seu projeto de aprendizado de máquina hello world em Python.

Aprendizado de Máquina em Python: Tutorial Passo a Passo (comece aqui)

Nesta seção, vamos trabalhar com um pequeno projeto de aprendizado de máquina de ponta a ponta.

Aqui está uma visão geral do que vamos cobrir:

1. Utilizaremos o Google Colab.
2. Carregando o conjunto de dados.
3. Resumindo o conjunto de dados.
4. Visualizando o conjunto de dados.
5. Avaliando alguns algoritmos.
6. Fazendo algumas previsões.

Não tenha pressa. Trabalhe em cada etapa.

Digite os comandos você mesmo, assim vai se familiarizando com a linguagem.

1. Google Colab

Clique no link: https://colab.research.google.com/?hl=pt_BR

Clique em novo notebook

Aqui já pode iniciar, os scripts da imagem estão logo mais abaixo…

Pronto, agora é só usar!

Importando as Bibliotecas que serão utilizadas…

# Libraries
import sys
import scipy
import numpy
import matplotlib
import pandas
import sklearn

Se você receber um erro, pare. Agora é a hora de consertar isso.

Se você não puder executar o script acima corretamente, não poderá concluir este tutorial.

Meu melhor conselho é pesquisar sua mensagem de erro no Google ou postar uma pergunta no Stack Overflow.

2. Carregar os dados

Vamos usar o conjunto de dados de flores da íris. Este conjunto de dados é famoso porque é usado como o conjunto de dados “hello world” em aprendizado de máquina e estatísticas por praticamente todos.

O conjunto de dados contém 150 observações de flores de íris. Existem quatro colunas de medidas das flores em centímetros. A quinta coluna é a espécie da flor observada. Todas as flores observadas pertencem a uma das três espécies.

Você pode aprender mais sobre este conjunto de dados na Wikipedia .

Nesta etapa, vamos carregar os dados da íris do CSV file URL.

2.1 Importar bibliotecas

Primeiro, vamos importar todos os módulos, funções e objetos que vamos usar neste tutorial.

# Load libraries
import pandas
from pandas.plotting import scatter_matrix
import matplotlib.pyplot as plt
from sklearn import model_selection
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC

2.2 Carregar Conjunto de Dados

Podemos carregar os dados diretamente do repositório UCI Machine Learning (mais fontes de dados, clique aqui).

Estamos usando pandas para carregar os dados. Também usaremos os pandas para explorar os dados, tanto com estatísticas descritivas quanto com visualização de dados.

Observe que estamos especificando os nomes de cada coluna ao carregar os dados. Isso ajudará mais tarde quando explorarmos os dados.

# load through url
url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'
attributes = ["sepal_length", "sepal_width", "petal_length", "petal_width", "class"]
dataset = pd.read_csv(url, names = attributes)
dataset.columns = attributes

O conjunto de dados deve carregar sem problemas.

Se você tiver problemas de rede, poderá baixar o arquivo iris.csv (disponível na internet) em seu diretório de trabalho e carregá-lo usando o mesmo método, alterando a URL para o nome do arquivo local.

3. Resumir o conjunto de dados

Agora é hora de dar uma olhada nos dados.

Nesta etapa, vamos dar uma olhada nos dados de algumas maneiras diferentes:

1. Dimensões do conjunto de dados.
2. Espreite os dados em si.
3. Resumo estatístico de todos os atributos.
4. Divisão dos dados pela variável de classe.

Não se preocupe, cada um dos dados é um comando. Estes são comandos úteis que você pode usar de novo e de novo em projetos futuros.

3.1 Dimensões do Dataset

Podemos ter uma ideia rápida de quantas instâncias (linhas) e quantos atributos (colunas) os dados contêm com a propriedade shape.

# shape
print(dataset.shape)

Você deve ver 150 instâncias e 5 atributos:

(150, 5)

3.2 Analise os dados

Também é sempre uma boa ideia analisar seus dados.

# head
print(dataset.head(20))

Você deve ver as primeiras 20 linhas dos dados:

3.3 Resumo estatístico

Agora podemos dar uma olhada em um resumo de cada atributo.

Isso inclui a contagem, a média, os valores mínimo e máximo, bem como alguns percentis.

# descriptions
print(dataset.describe())

Podemos ver que todos os valores numéricos têm a mesma escala (centímetros) e intervalos semelhantes entre 0 e 8 centímetros.

3.4 Distribuição de Classe

Vamos agora dar uma olhada no número de instâncias (linhas) que pertencem a cada classe. Podemos ver isso como uma contagem absoluta.

# class distribution
print(dataset.groupby(‘class’).size())

Podemos ver que cada classe tem o mesmo número de instâncias (50 ou 33% do conjunto de dados).

class
Iris-setosa 50
Iris-versicolor 50
Iris-virginica 50

4. Visualização de Dados

Agora temos uma ideia básica sobre os dados. Precisamos estender isso com algumas visualizações.

Vamos ver dois tipos de gráficos:

1. Gráficos univariados para entender melhor cada atributo.
2. Gráficos multivariados para entender melhor as relações entre os atributos.

4.1 Gráficos Univariados

Começamos com alguns gráficos univariados, ou seja, gráficos de cada variável individual.

Dado que as variáveis ​​de entrada são numéricas, podemos criar gráficos de caixa e bigode de cada um.

# box and whisker plots
dataset.plot(kind=’box’, subplots=True, layout=(2,2), sharex=False, sharey=False)
plt.show()

Isso nos dá uma ideia muito mais clara da distribuição dos atributos de entrada:

Também podemos criar um histograma de cada variável de entrada para ter uma ideia da distribuição.

# histograms
dataset.hist()
plt.show()

Parece que talvez duas das variáveis ​​de entrada tenham uma distribuição gaussiana. Isso é útil para observar como podemos usar algoritmos que podem explorar essa suposição.

4.2 Gráficos Multivariados

Agora podemos observar as interações entre as variáveis.

Primeiro, vamos olhar para gráficos de dispersão de todos os pares de atributos. Isso pode ser útil para identificar relações estruturadas entre variáveis ​​de entrada.

# scatter plot matrix
scatter_matrix(dataset)
plt.show()

Observe o agrupamento diagonal de alguns pares de atributos. Isso sugere uma alta correlação e um relacionamento previsível.

5. Avalie Algoritmos

Agora é hora de criar alguns modelos dos dados e estimar sua precisão em dados não vistos.

Aqui está o que vamos cobrir nesta etapa:

1. Separe um conjunto de dados de validação.
2. Configure os testes para utilizar validação cruzada de 10.
3. Construa 5 modelos diferentes para prever espécies a partir de medições de flores
4. Selecione o melhor modelo.

5.1 Criar um conjunto de dados de validação

Precisamos saber que o modelo que criamos é bom.

Mais tarde, usaremos métodos estatísticos para estimar a precisão dos modelos que criamos em dados não vistos. Também queremos uma estimativa mais concreta da precisão do melhor modelo em dados não vistos, avaliando-o em dados reais não vistos.

Ou seja, vamos reter alguns dados que os algoritmos não conseguirão ver e usaremos esses dados para obter uma segunda e independente ideia de quão preciso o melhor modelo pode realmente ser.

Vamos dividir o conjunto de dados carregado em dois, 80% dos quais usaremos para treinar nossos modelos e 20% que iremos reter como um conjunto de dados de validação.

# Split-out validation dataset
array = dataset.values
X = array[:,0:4]
Y = array[:,4]
validation_size = 0.20
seed = 7
X_train, X_validation, Y_train, Y_validation = model_selection.train_test_split(X, Y, test_size=validation_size, random_state=seed)

Agora você tem dados de treinamento no X_train e no Y_train para preparar modelos e um X_validation e Y_validation sets que podemos usar mais tarde.

Observe que usamos uma fatia python para selecionar as colunas na matriz NumPy. Se isso é novidade para você, talvez você queira fazer o check-out desta postagem:

• Como indexar, cortar e remodelar os arrays NumPy para aprendizado de máquina em Python

5.2 Test Harness

Usaremos a validação cruzada (cross-validation) de 10 vezes para estimar a precisão.

Isso dividirá nosso conjunto de dados em 10 partes, treinar em 9 e testar em 1 e repetir para todas as combinações de divisões de teste de trem.

# Test options and evaluation metric
seed = 7
scoring = ‘accuracy’

A semente aleatória (random seed) específica não importa, aprenda mais sobre geradores de números pseudo-aleatórios aqui:

• Introdução aos Geradores de Números Aleatórios para Aprendizado de Máquina em Python

Estamos usando a métrica de “accuracy” para avaliar modelos. Essa é uma proporção do número de instâncias corretamente previstas divididas pelo número total de instâncias no conjunto de dados multiplicado por 100 para fornecer uma porcentagem (por exemplo, 95% de accurate). Nós estaremos usando a variável de pontuação quando nós executarmos construir e avaliar cada modelo a seguir.

5.3 Construir Modelos

Não sabemos quais algoritmos seriam bons nesse problema ou quais configurações usar. Nós temos uma ideia das parcelas de que algumas das classes são parcialmente linearmente separáveis ​​em algumas dimensões, então esperamos resultados geralmente bons.

Vamos avaliar 6 algoritmos diferentes:

• Regressão Logística (LR)
• Análise Linear Discriminante (LDA)
• K-vizinhos mais próximos (KNN).
• Árvores de Classificação (Decision Tree) e Regressão (CART).
• Gaussian Naive Bayes (NB).
• Support Vector Machines (SVM).

Esta é uma boa mistura de algoritmos simples lineares (LR e LDA), não lineares (KNN, CART, NB e SVM). Redefinimos a semente numérica aleatória antes de cada execução para garantir que a avaliação de cada algoritmo seja executada usando exatamente as mesmas divisões de dados. Isso garante que os resultados sejam diretamente comparáveis.

Vamos construir e avaliar nossos modelos:

# Spot Check Algorithms
models = []
models.append((‘LR’, LogisticRegression(solver=’liblinear’, multi_class=’ovr’)))
models.append((‘LDA’, LinearDiscriminantAnalysis()))
models.append((‘KNN’, KNeighborsClassifier()))
models.append((‘CART’, DecisionTreeClassifier()))
models.append((‘NB’, GaussianNB()))
models.append((‘SVM’, SVC(gamma=’auto’)))
# evaluate each model in turn
results = []
names = []
for name, model in models:
   kfold = model_selection.KFold(n_splits=10, random_state=seed)
   cv_results = model_selection.cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring)
   results.append(cv_results)
   names.append(name)
   msg = “%s: %f (%f)” % (name, cv_results.mean(), cv_results.std())
   print(msg)

5.4 Selecione o melhor modelo

Agora temos 6 modelos e estimativas de precisão para cada um. Precisamos comparar os modelos entre si e selecionar os mais precisos.

Executando o exemplo acima, obtemos os seguintes resultados brutos:

Note que os seus resultados podem ser diferentes. Para mais informações, veja o post:

• Abraçar a Aleatoriedade no Aprendizado de Máquina

Nesse caso, podemos ver que parece que o Support Vector Machines (SVM) tem a maior pontuação de accuracy estimada.

Também podemos criar um gráfico dos resultados da avaliação do modelo e comparar o spread e a accuracy média de cada modelo. Há uma população de medidas de accuracy para cada algoritmo porque cada algoritmo foi avaliado 10 vezes (10 fold cross validation).

# Compare Algorithms
fig = plt.figure()
fig.suptitle(‘Algorithm Comparison’)
ax = fig.add_subplot(111)
plt.boxplot(results)
ax.set_xticklabels(names)
plt.show()

Você pode ver que as plotagens de caixa e bigode estão esmagadas no topo da faixa, com muitas amostras atingindo 100% de accuracy.

6. Faça previsões

O algoritmo KNN é muito simples e foi um modelo preciso baseado em nossos testes. Agora queremos ter uma ideia da accuracy do modelo em nosso conjunto de validação.

Isso nos dará uma verificação final independente da accuracy do melhor modelo. É importante manter um conjunto de validação apenas no caso de você ter feito uma falha durante o treinamento, como overfitting no conjunto de treinamento ou um vazamento de dados. Ambos resultarão em um resultado excessivamente otimista.

Podemos executar o modelo KNN diretamente no conjunto de validação e resumir os resultados como uma pontuação final de accuracy , uma matriz de confusão e um relatório de classificação.

# Make predictions on validation dataset
knn = KNeighborsClassifier()
knn.fit(X_train, Y_train)
predictions = knn.predict(X_validation)
print(accuracy_score(Y_validation, predictions))
print(confusion_matrix(Y_validation, predictions))
print(classification_report(Y_validation, predictions))

Podemos ver que a accuracy é de 0,9 ou 90%. A matriz de confusão fornece uma indicação dos três erros cometidos. Finalmente, o relatório de classificação fornece um detalhamento de cada classe por precisão, recall, pontuação-f1 e suporte mostrando resultados excelentes (dado que o conjunto de dados de validação era pequeno).

Você pode aprender mais sobre como fazer previsões e prever probabilidades aqui:

• Como fazer previsões com o scikit-learn

Você pode fazer aprendizado de máquina em Python

Trabalhe no tutorial acima. Isso levará de 5 a 10 minutos, no máximo!

Você não precisa entender tudo . (pelo menos não agora) Seu objetivo é percorrer o tutorial de ponta a ponta e obter um resultado. Você não precisa entender tudo na primeira passagem. Faça uma lista das suas perguntas. Faça uso intensivo da ajuda (“FunctionName”) na sintaxe de ajuda em Python para aprender sobre todas as funções que você está usando.

Você não precisa saber como os algoritmos funcionam . É importante conhecer as limitações e como configurar algoritmos de aprendizado de máquina. Mas aprender sobre algoritmos pode vir depois. Você precisa desenvolver esse conhecimento de algoritmo lentamente durante um longo período de tempo. Hoje, comece ficando confortável com a plataforma.

Você não precisa ser um programador Python . A sintaxe da linguagem Python pode ser intuitiva se você for novo para ela. Assim como em outros idiomas, concentre-se em chamadas de função (por exemplo, function () ) e atribuições (por exemplo, a = “b” ). Isso vai te dar a maior parte do caminho. Você é um desenvolvedor, sabe como aprender o básico de uma linguagem rapidamente. Apenas comece e mergulhe nos detalhes mais tarde.

Você não precisa ser um especialista em aprendizado de máquina . Você pode aprender sobre os benefícios e limitações de vários algoritmos posteriormente, e há muitos posts que você pode ler mais tarde para revisar as etapas de um projeto de aprendizado de máquina e a importância de avaliar a precisão usando validação cruzada.

Originalmente escrito por Jason Brownlee (todos direitos reservados ao autor)
Traduzido pelo Google Translator — Adaptações para PT-BR e no script— Alex Souza

Veja aqui o Notebook deste primeiro projeto (Notebook)

Vejam também:
- Introdução ao Machine Learning
- Fundamentos dos Algoritmos de Aprendizado de Máquina (com Códigos Python e R)
- O que você precisa saber sobre o aprendizado de máquina…