Machine Learning. Você, provavelmente, já ouviu esse termo em algum lugar. Está em todo canto. Netflix recomendando filmes, Spotify sugerindo músicas, e até o seu banco detectando transações suspeitas. Mas o que é isso de verdade?
Quando comecei a estudar Machine Learning, confesso que fiquei intimidado. Parecia algo muito complexo, cheio de matemática pesada e conceitos abstratos. Mas a verdade é que, com as ferramentas certas, você consegue criar seu primeiro modelo em poucos minutos. E é isso que vamos fazer hoje.
O que é Machine Learning?
Em termos simples, Machine Learning é ensinar o computador a aprender padrões a partir de dados. Em vez de programar regras específicas como "se X então Y", você mostra exemplos para o algoritmo e ele descobre as regras sozinho.
Pensa assim: você quer ensinar uma criança a identificar gatos. Você não explica "gato tem quatro patas, bigodes, orelhas pontudas...". Você simplesmente mostra várias fotos de gatos e diz "isso é um gato". Depois de ver muitos exemplos, a criança aprende a reconhecer gatos por conta própria. Machine Learning funciona de forma parecida.
O que é sklearn?
Scikit-learn, ou simplesmente sklearn, é a biblioteca mais popular de Machine Learning em Python. Ela é gratuita, bem documentada e tem uma API consistente que facilita muito a vida de quem está começando.
Com sklearn você consegue fazer classificação, regressão, clustering e muito mais. Tudo com poucas linhas de código.
Instalação
Lembre-se que tenho instruções de como criar um ambiente virtual que facilita muito a vida de um cientista de dados.
Antes de começar, você precisa ter o sklearn instalado. Se ainda não tem, rode no terminal:
pip install scikit-learn
Vamos também usar pandas e numpy, que provavelmente você já tem:
pip install pandas numpy
Seu Primeiro Modelo: Classificando Flores
Vamos usar o dataset Iris, um clássico para quem está aprendendo. Ele contém medidas de 150 flores de três espécies diferentes. Nosso objetivo é criar um modelo que, dado as medidas de uma flor, consiga prever qual é a espécie.
Carregando os Dados
from sklearn.datasets import load_iris
import pandas as pd
# Carregando o dataset
iris = load_iris()
# Criando um DataFrame para visualizar melhor
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['especie'] = iris.target
print(df.head())
Isso vai mostrar algo assim:
sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) especie 0 5.1 3.5 1.4 0.2 0 1 4.9 3.0 1.4 0.2 0 2 4.7 3.2 1.3 0.2 0 3 4.6 3.1 1.5 0.2 0 4 5.0 3.6 1.4 0.2 0
Temos 4 características (features) e um target (espécie). O target é numérico: 0, 1 ou 2, representando as três espécies de Iris.
Dividindo os Dados
Uma regra de ouro em Machine Learning: nunca teste seu modelo com os mesmos dados que usou para treinar. Isso seria como dar a prova para o aluno estudar e depois aplicar a mesma prova. Não dá pra saber se ele realmente aprendeu.
Por isso dividimos os dados em treino e teste:
from sklearn.model_selection import train_test_split
X = iris.data # features
y = iris.target # target
X_treino, X_teste, y_treino, y_teste = train_test_split(
X, y,
test_size=0.3, # 30% para teste
random_state=42 # para reprodutibilidade
)
print(f"Dados de treino: {len(X_treino)}")
print(f"Dados de teste: {len(X_teste)}")
Saída:
Dados de treino: 105 Dados de teste: 45
Treinando o Modelo
Agora vem a parte legal. Vamos usar um algoritmo chamado K-Nearest Neighbors (KNN). A ideia dele é simples: para classificar um novo dado, ele olha os K vizinhos mais próximos e vê qual classe é mais comum entre eles.
from sklearn.neighbors import KNeighborsClassifier
# Criando o modelo
modelo = KNeighborsClassifier(n_neighbors=3)
# Treinando com os dados de treino
modelo.fit(X_treino, y_treino)
Pronto. Duas linhas e seu modelo está treinado.
Fazendo Previsões
Agora podemos usar o modelo para prever as espécies das flores que ele nunca viu (dados de teste):
previsoes = modelo.predict(X_teste)
print("Primeiras 10 previsões:", previsoes[:10])
print("Valores reais:", y_teste[:10])
Avaliando o Modelo
Mas, como saber se o modelo está bom? A métrica mais simples é a acurácia: quantos acertos dividido pelo total.
from sklearn.metrics import accuracy_score
acura cia = accuracy_score(y_teste, previsoes)
print(f"Acurácia: {acuracia:.2%}")
Saída:
Acurácia: 97.78%
Nada mal para um primeiro modelo, né?
O Padrão sklearn
Uma coisa muito boa do sklearn é que todos os modelos seguem o mesmo padrão. Não importa se você está usando KNN, Árvore de Decisão, ou Regressão Logística, o fluxo é sempre:
from sklearn.algum_modulo import AlgumModelo
modelo = AlgumModelo() # 1. Criar
modelo.fit(X_treino, y_treino) # 2. Treinar
previsoes = modelo.predict(X_teste) # 3. Prever
Quer testar outro algoritmo? Só trocar o modelo:
from sklearn.tree import DecisionTreeClassifier
modelo_arvore = DecisionTreeClassifier()
modelo_arvore.fit(X_treino, y_treino)
previsoes_arvore = modelo_arvore.predict(X_teste)
print(f"Acurácia Árvore: {accuracy_score(y_teste, previsoes_arvore):.2%}")
Código Completo
Aqui está tudo junto para você copiar e rodar:
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
import pandas as pd
# Carregando dados
iris = load_iris()
X = iris.data
y = iris.target
# Dividindo em treino e teste
X_treino, X_teste, y_treino, y_teste = train_test_split(
X, y, test_size=0.3, random_state=42
)
# Criando e treinando o modelo
modelo = KNeighborsClassifier(n_neighbors=3)
modelo.fit(X_treino, y_treino)
# Fazendo previsões
previsoes = modelo.predict(X_teste)
# Avaliando
acuracia = accuracy_score(y_teste, previsoes)
print(f"Acurácia: {acuracia:.2%}")
Próximos Passos
Esse foi só o começo. Machine Learning é um mundo imenso. Algumas coisas que você pode explorar depois:
- Entender a diferença entre classificação e regressão
- Aprender sobre overfitting e como evitar
- Conhecer outros algoritmos como Random Forest e SVM
- Explorar métricas além da acurácia, como precisão e recall
Mas, por enquanto, o importante é que você deu o primeiro passo. Você criou um modelo de Machine Learning. Parabéns!
Conclusão
Machine Learning não precisa ser complicado. Com sklearn, você consegue criar modelos poderosos com poucas linhas de código. O segredo é começar simples, entender os conceitos básicos, e ir evoluindo aos poucos.
Se você gostou desse tutorial, fica ligado que em breve vou trazer mais conteúdo sobre Machine Learning. Vamos explorar outros algoritmos, técnicas de pré-processamento e até criar projetos mais complexos.
Até a próxima!
Comentários (0)
Seja o primeiro a comentar!
Deixe um comentário