O Scikit-learn é uma das bibliotecas mais populares de Machine Learning em Python. Ele foi criado para ajudar iniciantes e especialistas a desenvolverem projetos de aprendizado de máquina de forma simples e prática.
Neste artigo, você vai aprender o que é o Scikit-learn, como instalá-lo e usá-lo para criar modelos de machine learning. Também veremos exemplos práticos e explicações claras para que qualquer pessoa, mesmo sem experiência em programação, possa acompanhar.
O que é o Scikit-learn?
O Scikit-learn é uma biblioteca gratuita e de código aberto. Ela foi construída sobre outras ferramentas importantes como o NumPy (para cálculos numéricos) e o Pandas (para manipulação de dados).
Com o Scikit-learn, você pode:
- Treinar modelos de classificação (por exemplo: identificar se um e-mail é spam).
- Criar modelos de regressão (por exemplo: prever o preço de uma casa).
- Usar algoritmos de agrupamento (por exemplo: dividir clientes em grupos com comportamentos parecidos).
- Fazer pré-processamento de dados (limpar, normalizar e preparar dados).
Ele é usado tanto em empresas quanto em universidades e é ideal para quem está começando a aprender machine learning.
Por que usar o Scikit-learn?
Existem muitas bibliotecas de machine learning no mercado, mas o Scikit-learn é um dos mais usados porque:
- É fácil de aprender e tem uma documentação completa.
- Funciona bem em computadores comuns.
- Tem suporte para dezenas de algoritmos prontos.
- Se integra com outras ferramentas como Pandas, NumPy e Matplotlib.
Resumindo: se você quer começar a aprender machine learning, o Scikit-learn é um ótimo ponto de partida.
Instalando o Scikit-learn
Antes de usar, precisamos instalar a biblioteca. Abra o terminal ou prompt de comando e digite:
pip install scikit-learnSe você já tem o Anaconda, pode instalar com:
conda install scikit-learnDepois de instalado, teste no Python:
import sklearn
print(sklearn.__version__)Se aparecer a versão instalada, a biblioteca está pronta para uso.
Estrutura básica de um projeto com Scikit-learn
Todo projeto de machine learning no Scikit-learn segue alguns passos básicos:
- Importar as bibliotecas.
- Carregar os dados.
- Dividir os dados em treino e teste.
- Escolher um modelo.
- Treinar o modelo.
- Fazer previsões.
- Avaliar os resultados.
Essa estrutura é quase sempre a mesma, independentemente do problema.
Exemplo simples: prever flores com Scikit-learn
Vamos começar com um exemplo clássico: o conjunto de dados Iris. Ele contém informações sobre três tipos de flores e suas medidas (largura e comprimento de pétalas e sépalas).
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
# Carregando os dados
iris = load_iris()
X = iris.data
y = iris.target
# Dividindo em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# Criando o modelo
modelo = KNeighborsClassifier(n_neighbors=3)
# Treinando o modelo
modelo.fit(X_train, y_train)
# Fazendo previsões
previsoes = modelo.predict(X_test)
print(previsoes)Esse código cria um modelo que tenta prever o tipo de flor com base em suas medidas.
Explicando cada parte do exemplo
- load_iris(): carrega o conjunto de dados Iris.
- train_test_split(): divide os dados em treino (80%) e teste (20%).
- KNeighborsClassifier: algoritmo usado para classificação.
- fit(): treina o modelo com os dados de treino.
- predict(): faz previsões nos dados de teste.
Esse é o fluxo básico de qualquer modelo no Scikit-learn.
Avaliando o modelo
Prever não basta. Precisamos saber se o modelo é bom. Para isso, usamos métricas de avaliação.
from sklearn.metrics import accuracy_score
acuracia = accuracy_score(y_test, previsoes)
print(acuracia)O resultado é um número entre 0 e 1. Se for 0.9, por exemplo, significa que o modelo acertou 90% dos casos.
Trabalhando com regressão
Além de classificação, o Scikit-learn também serve para regressão. Isso é útil quando queremos prever valores numéricos, como o preço de uma casa.
Exemplo com Regressão Linear:
import numpy as np
from sklearn.linear_model import LinearRegression
# Dados de exemplo
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])
# Criando o modelo
modelo = LinearRegression()
# Treinando
modelo.fit(X, y)
# Fazendo previsões
previsao = modelo.predict([[6]])
print(previsao)Resultado esperado: 12. Isso mostra que o modelo aprendeu a relação entre os números.
Pré-processamento de dados
Na prática, os dados do mundo real não são organizados. Eles podem ter valores faltando, escala diferente ou informações desnecessárias.
O Scikit-learn tem ferramentas para:
- Normalização: deixar todos os dados na mesma escala.
- Codificação: transformar texto em números.
- Tratamento de valores ausentes.
Exemplo de normalização:
from sklearn.preprocessing import StandardScaler
import numpy as np
dados = np.array([[10], [20], [30]])
scaler = StandardScaler()
normalizados = scaler.fit_transform(dados)
print(normalizados)Isso ajusta os dados para que fiquem em uma escala parecida, o que ajuda muitos algoritmos.
Algoritmos populares no Scikit-learn
O Scikit-learn já vem com dezenas de algoritmos prontos. Alguns dos mais usados são:
- Regressão Linear (LinearRegression)
- Árvore de Decisão (DecisionTreeClassifier)
- Random Forest (RandomForestClassifier)
- Máquinas de Vetores de Suporte (SVM) (SVC)
- K-Nearest Neighbors (KNN) (KNeighborsClassifier)
- Regressão Logística (LogisticRegression)
Cada algoritmo tem pontos fortes e fracos. Por isso, é comum testar vários e escolher o melhor.
Visualizando resultados com gráficos
Para entender melhor os modelos, podemos usar gráficos com a biblioteca Matplotlib.
import matplotlib.pyplot as plt
import numpy as np
# Dados simples
X = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 6, 8, 10])
# Modelo
from sklearn.linear_model import LinearRegression
modelo = LinearRegression()
modelo.fit(X.reshape(-1, 1), y)
# Linha prevista
y_pred = modelo.predict(X.reshape(-1, 1))
# Gráfico
plt.scatter(X, y, color="blue")
plt.plot(X, y_pred, color="red")
plt.show()Esse gráfico mostra os pontos originais em azul e a linha de previsão em vermelho.
Exemplo do mundo real: previsão de preços de casas
Imagine que você tem informações sobre casas: quantidade de quartos, tamanho e localização. Com o Scikit-learn, você pode treinar um modelo para prever o preço da casa.
O processo é o mesmo: carregar os dados, dividir em treino e teste, escolher um algoritmo de regressão e avaliar os resultados.
Esse tipo de aplicação é usado por imobiliárias, bancos e plataformas de aluguel.
Dicas para começar com Scikit-learn
- Comece com conjuntos de dados pequenos, como o Iris.
- Teste diferentes algoritmos e compare resultados.
- Use métricas simples, como acurácia ou erro médio absoluto.
- Não se preocupe em entender a matemática no início.
- Pratique muito. Machine learning se aprende com exemplos.
Conclusão
O Scikit-learn no Python é uma ferramenta poderosa e acessível. Ele permite que qualquer pessoa, mesmo sem experiência prévia, crie modelos de machine learning.
Com alguns comandos, você pode treinar modelos para classificação, regressão e até problemas mais avançados. A chave é praticar e testar diferentes algoritmos.
Se você quer dar os primeiros passos no aprendizado de máquina, o Scikit-learn é a escolha ideal.
Perguntas Frequentes (FAQ)
1. O que é Scikit-learn?
É uma biblioteca de Python para criar modelos de machine learning de forma simples.
2. Preciso saber matemática para usar Scikit-learn?
Não no início. Você pode aprender a prática primeiro e estudar a teoria depois.
3. O Scikit-learn é gratuito?
Sim. Ele é 100% gratuito e de código aberto.
4. Preciso de um computador potente para usar Scikit-learn?
Não. Ele funciona bem em computadores comuns.
5. Qual a diferença entre classificação e regressão?
Classificação prevê categorias. Regressão prevê valores numéricos.
6. Como instalar o Scikit-learn?
Use o comando pip install scikit-learn.
7. Posso usar Scikit-learn com dados do Excel?
Sim. Basta carregar os dados com Pandas e usar no modelo.
8. O Scikit-learn serve para inteligência artificial avançada?
Ele é ótimo para aprendizado de máquina tradicional, mas não para deep learning.
9. Quais algoritmos estão no Scikit-learn?
Regressão Linear, KNN, Árvores de Decisão, Random Forest, SVM e muitos outros.
10. Preciso saber programar para usar o Scikit-learn?
Um pouco sim. O básico de Python já é suficiente para começar.
11. Posso usar Scikit-learn no Google Colab?
Sim. Ele já vem instalado por padrão no Colab.
12. Qual o primeiro projeto que devo tentar?
O clássico é o conjunto de dados Iris, que é simples e bem conhecido.
