Introdução
Scripts em Python para machine learning são essenciais para quem quer aplicar inteligência artificial de forma prática e eficiente no dia a dia profissional. Se você busca colocar a mão na massa com projetos reais, nada melhor do que contar com códigos prontos que resolvem desafios concretos. Neste artigo, você vai conhecer 5 exemplos funcionais, da análise de sentimentos à previsão de vendas que utilizam bibliotecas como Scikit-learn, Pandas e Matplotlib. Eles são ideais para empresas que precisam de soluções ágeis e adaptáveis.
Pré-requisitos
Para executar os scripts com sucesso, confira os seguintes itens:
- Ambiente recomendado: Python 3.8 ou superior (utilizar Anaconda ou Google Colab facilita).
- Bibliotecas necessárias:
pandas,numpy,scikit-learn,matplotlib,seaborn,textblob(quando precisar tratar texto). - Conhecimento prévio: Comandos básicos de Python e noções fundamentais de ML.
- Instalação via pip:
pip install pandas numpy scikit-learn matplotlib seaborn textblob
1. Classificação de Sentimentos com Análise de Texto
Desafio
Identificar se um texto—como um review ou feedback—expressa sentimentos positivos, negativos ou neutros permite entender a percepção do cliente e refinar estratégias de produto.
Script comentado
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report
# Dataset simulado de frases com sentimento
data = {
'texto': ['Produto excelente, recomendo', 'Muito ruim, não comprem',
'Mediano, nada especial', 'Adorei a qualidade', 'Péssimo atendimento'],
'sentimento': ['positivo', 'negativo', 'neutro', 'positivo', 'negativo']
}
df = pd.DataFrame(data)
# TF‑IDF para transformar texto em vetores
vectorizer = TfidfVectorizer(max_features=1000, stop_words='english')
X = vectorizer.fit_transform(df['texto'])
y = df['sentimento']
# Dividir os dados em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Treinar o modelo de Regressão Logística
model = LogisticRegression()
model.fit(X_train, y_train)
# Avaliar o modelo
y_pred = model.predict(X_test)
print(f"Acurácia: {accuracy_score(y_test, y_pred):.2f}")
print(classification_report(y_test, y_pred))
O que esperar
Você verá a acurácia do modelo e um relatório com precisão, recall e F1-score por classe, oferecendo uma visão clara de desempenho.
2. Previsão de Vendas com Regressão Linear
Desafio
Usar dados históricos para prever vendas futuras facilita o planejamento de marketing, produção e estoque.
Script comentado
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
# Dados de vendas simulados por mês
meses = np.arange(1, 13).reshape(-1, 1)
vendas = np.array([150, 170, 180, 220, 250, 290, 310, 330, 280, 260, 240, 200])
# Criar e treinar o modelo
modelo = LinearRegression()
modelo.fit(meses, vendas)
# Fazer previsões
predicoes = modelo.predict(meses)
venda_proximo = modelo.predict([[13]])
# Visualizar o resultado
plt.figure(figsize=(10, 6))
plt.scatter(meses, vendas, color='blue', label='Vendas reais')
plt.plot(meses, predicoes, color='red', label='Tendência')
plt.title('Previsão de Vendas com Regressão Linear')
plt.xlabel('Mês')
plt.ylabel('Vendas (unidades)')
plt.legend()
plt.show()
print(f"Previsão para o próximo mês: {venda_proximo[0]:.0f} unidades")
print(f"R²: {r2_score(vendas, predicoes):.3f}")
O que esperar
Um gráfico visualizando a linha de tendência das vendas e um valor estimado para o próximo mês, com métrica R² indicando a qualidade do ajuste.
3. Segmentação de Clientes com K‑Means
Desafio
Agrupar clientes com base em características semelhantes permite campanhas de marketing mais eficazes e focadas.
Script comentado
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
# Simulação de dados de clientes
clientes = {
'idade': [25, 35, 45, 23, 40, 50, 28, 33, 48, 29],
'renda': [3000, 5000, 7000, 2500, 6000, 8000, 3500, 4500, 7500, 3200],
'gasto_mensal': [800, 1200, 1800, 600, 1500, 2000, 900, 1100, 1900, 850]
}
df_clientes = pd.DataFrame(clientes)
# Normalizar os dados
scaler = StandardScaler()
dados_norm = scaler.fit_transform(df_clientes)
# Aplicar K‑Means com 3 clusters
kmeans = KMeans(n_clusters=3, random_state=42)
df_clientes['cluster'] = kmeans.fit_predict(dados_norm)
# Visualizar os grupos
plt.figure(figsize=(10, 6))
cores = ['red', 'blue', 'green']
for i in range(3):
cluster_i = df_clientes[df_clientes['cluster'] == i]
plt.scatter(cluster_i['renda'], cluster_i['gasto_mensal'],
color=cores[i], label=f'Cluster {i}', s=50)
plt.title('Segmentação de Clientes (K‑Means)')
plt.xlabel('Renda')
plt.ylabel('Gasto Mensal')
plt.legend()
plt.show()
print(df_clientes.groupby('cluster').mean())
O que esperar
Um gráfico agrupando os clientes por perfil e uma tabela com as médias de cada cluster para idade, renda e gasto mensal.
4. Detecção de Anomalias em Transações Financeiras
Desafio
Detectar transações atípicas é essencial para identificar fraudes com rapidez.
Script comentado
import numpy as np
from sklearn.ensemble import IsolationForest
import matplotlib.pyplot as plt
# Criar dados simulados: maioria normal, algumas anômalas
np.random.seed(42)
normais = np.random.normal(1000, 200, 950)
anomalias = np.random.normal(5000, 500, 50)
transacoes = np.concatenate([normais, anomalias]).reshape(-1, 1)
# Treinar o modelo Isolation Forest
detector = IsolationForest(contamination=0.1, random_state=42)
preds = detector.fit_predict(transacoes)
# Separar os dados detectados como anomalia ou não
trans_normais = transacoes[preds == 1]
trans_anomalias = transacoes[preds == -1]
# Visualizar com histograma
plt.figure(figsize=(12, 6))
plt.hist(trans_normais, bins=50, alpha=0.6, label='Normais', color='blue')
plt.hist(trans_anomalias, bins=20, alpha=0.6, label='Anômalas', color='red')
plt.title('Detecção de Anomalias em Transações')
plt.xlabel('Valor da Transação')
plt.ylabel('Frequência')
plt.legend()
plt.show()
print(f"Total de transações: {len(transacoes)}")
print(f"Anomalias detectadas: {len(trans_anomalias)}")
print(f"Percentual de anomalias: {len(trans_anomalias) / len(transacoes) * 100:.1f}%")
O que esperar
Um histograma diferenciando transações normais e suspeitas, junto com estatísticas quantitativas da detecção.
5. Recomendação de Produtos com Similaridade entre Usuários
Desafio
Sugerir produtos relevantes com base no histórico de avaliações torna a experiência do usuário mais personalizada.
Script comentado
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity
# Dados simulados de avaliações
avaliacoes = {
'usuario': ['Ana', 'Bruno', 'Carlos', 'Diana', 'Eduardo'],
'produto_A': [5, 3, 4, 2, 5],
'produto_B': [4, 5, 3, 4, 2],
'produto_C': [3, 4, 5, 3, 4],
'produto_D': [2, 2, 2, 5, 3]
}
df = pd.DataFrame(avaliacoes).set_index('usuario')
# Medir similaridade entre usuários
sim = cosine_similarity(df)
df_sim = pd.DataFrame(sim, index=df.index, columns=df.index)
def recomendar(usuario, n=2):
similares = df_sim[usuario].sort_values(ascending=False)[1:]
recom = {}
for prod in df.columns:
if df.loc[usuario, prod] == 0:
score = sum(df_sim.loc[usuario, outro] * df.loc[outro, prod]
for outro in similares.index if df.loc[outro, prod] > 0)
recom[prod] = score
return sorted(recom.items(), key=lambda x: x[1], reverse=True)[:n]
usuario_teste = 'Ana'
recs = recomendar(usuario_teste)
print(f"Recomendações para {usuario_teste}:")
for prod, pont in recs:
print(f"- {prod}: score {pont:.2f}")
O que esperar
Uma lista de produtos recomendados para o usuário alvo, acompanhada de um score que indica relevância.
Conclusão
Você viu cinco scripts que cobrem aplicações fundamentais de ML — análise de sentimentos, previsão de vendas, segmentação de clientes, detecção de anomalias e recomendação de produtos. Todos seguem arquitetura leve e são fáceis de adaptar ao seu próprio dataset. Para projetos mais robustos, pense em evoluir com validação cruzada, busca de hiperparâmetros (como GridSearch) e deploy dos modelos em produção.
Dica Final
Experimente rodar esses exemplos com seus próprios dados. Se criar variações interessantes ou aplicar de forma inovadora, compartilhe suas experiências, contribuindo com a comunidade!
Texto revisado por Márcia Souza, com foco em clareza e exatidão.
