Guia de Python para
Inteligência Artificial
Sumário
1. Introdução ao Python para IA
2. Bibliotecas Essenciais
3. Preparação e Manipulação de Dados
4. Machine Learning com Scikit-learn
5. Deep Learning com TensorFlow/Keras
6. Projetos Práticos
7. Recursos Adicionais
1. Introdução ao Python para IA
Python é a linguagem mais popular para desenvolvimento de projetos de Inteligência Artificial devido à sua sintaxe
simples, vasta comunidade e rico ecossistema de bibliotecas especializadas.
Por que Python para IA?
Sintaxe clara e legível: Facilita o desenvolvimento e manutenção de código
Bibliotecas especializadas: NumPy, Pandas, Scikit-learn, TensorFlow, PyTorch
Comunidade ativa: Grande quantidade de recursos, tutoriais e suporte
Interpretação interativa: Jupyter Notebooks para experimentação
Multiplataforma: Funciona em Windows, macOS e Linux
Configuração do Ambiente
# Instalação das bibliotecas essenciais
pip install numpy pandas matplotlib seaborn
pip install scikit-learn tensorflow keras
pip install jupyter notebook
2. Bibliotecas Essenciais
NumPy - Computação Numérica
import numpy as np
# Criação de arrays
arr = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2], [3, 4]])
# Operações matemáticas
result = np.dot(matrix, matrix.T)
Pandas - Manipulação de Dados
import pandas as pd
# Leitura de dados
df = pd.read_csv('dados.csv')
# Análise exploratória
print(df.describe())
print(df.info())
Matplotlib/Seaborn - Visualização
import matplotlib.pyplot as plt
import seaborn as sns
# Gráfico simples
plt.plot([1, 2, 3, 4], [1, 4, 2, 3])
plt.show()
# Heatmap com correlações
sns.heatmap(df.corr(), annot=True)
3. Preparação e Manipulação de Dados
Limpeza de Dados
# Tratamento de valores ausentes
df.dropna() # Remove linhas com valores nulos
df.fillna(0) # Preenche com zeros
# Remoção de duplicatas
df.drop_duplicates()
# Tratamento de outliers
Q1 = df.quantile(0.25)
Q3 = df.quantile(0.75)
IQR = Q3 - Q1
df = df[~((df < (Q1 - 1.5 * IQR)) | (df > (Q3 + 1.5 * IQR))).any(axis=1)]
Engenharia de Features
from sklearn.preprocessing import StandardScaler, LabelEncoder
# Normalização
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# Codificação de variáveis categóricas
encoder = LabelEncoder()
y_encoded = encoder.fit_transform(y)
4. Machine Learning com Scikit-learn
Classificação
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
# Divisão dos dados
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Treinamento do modelo
clf = RandomForestClassifier(n_estimators=100)
clf.fit(X_train, y_train)
# Predições e avaliação
y_pred = clf.predict(X_test)
print(f"Acurácia: {accuracy_score(y_test, y_pred)}")
print(classification_report(y_test, y_pred))
Regressão
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
# Modelo de regressão
reg = LinearRegression()
reg.fit(X_train, y_train)
# Avaliação
y_pred = reg.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
Clustering
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
# K-Means
kmeans = KMeans(n_clusters=3)
labels = kmeans.fit_predict(X)
# Visualização
plt.scatter(X[:, 0], X[:, 1], c=labels)
plt.show()
5. Deep Learning com TensorFlow/Keras
Rede Neural Simples
import tensorflow as tf
from tensorflow import keras
# Criação do modelo
model = keras.Sequential([
keras.layers.Dense(128, activation='relu', input_shape=(784,)),
keras.layers.Dropout(0.2),
keras.layers.Dense(10, activation='softmax')
])
# Compilação
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# Treinamento
model.fit(X_train, y_train, epochs=10, validation_split=0.2)
Rede Neural Convolucional (CNN)
# CNN para classificação de imagens
model = keras.Sequential([
keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
keras.layers.MaxPooling2D((2, 2)),
keras.layers.Conv2D(64, (3, 3), activation='relu'),
keras.layers.MaxPooling2D((2, 2)),
keras.layers.Flatten(),
keras.layers.Dense(64, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
Processamento de Linguagem Natural (NLP)
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
# Tokenização
tokenizer = Tokenizer(num_words=10000)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
# Padding
padded = pad_sequences(sequences, maxlen=100)
# Modelo para NLP
model = keras.Sequential([
keras.layers.Embedding(10000, 128),
keras.layers.LSTM(64),
keras.layers.Dense(1, activation='sigmoid')
])
6. Projetos Práticos
Projeto 1: Classificador de Íris
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
# Carregamento dos dados
iris = load_iris()
X, y = iris.data, iris.target
# Treinamento e validação cruzada
clf = RandomForestClassifier()
scores = cross_val_score(clf, X, y, cv=5)
print(f"Acurácia média: {scores.mean():.3f}")
Projeto 2: Previsão de Preços de Casas
from sklearn.datasets import load_boston
from sklearn.ensemble import GradientBoostingRegressor
# Dados
boston = load_boston()
X, y = boston.data, boston.target
# Modelo
gbr = GradientBoostingRegressor(n_estimators=100)
gbr.fit(X_train, y_train)
# Avaliação
score = gbr.score(X_test, y_test)
print(f"R² Score: {score:.3f}")
Projeto 3: Sistema de Recomendação
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity
# Matriz usuário-item
user_item_matrix = pd.pivot_table(df, values='rating',
index='user_id',
columns='item_id')
# Similaridade entre usuários
user_similarity = cosine_similarity(user_item_matrix.fillna(0))
# Geração de recomendações
def recommend_items(user_id, num_recommendations=5):
# Lógica de recomendação baseada em similaridade
pass
7. Recursos Adicionais
Boas Práticas
Versionamento de código: Use Git para controle de versão
Documentação: Comente seu código e use docstrings
Testes: Implemente testes unitários
Virtualenv: Use ambientes virtuais para isolamento de dependências
Ferramentas Úteis
Jupyter Notebooks: Para exploração interativa
Google Colab: Para acesso a GPUs gratuitas
MLflow: Para tracking de experimentos
Docker: Para containerização de aplicações
Próximos Passos
1. Pratique com datasets reais (Kaggle, UCI ML Repository)
2. Participe de competições de machine learning
3. Contribua para projetos open source
4. Explore áreas especializadas (Computer Vision, NLP, Reinforcement Learning)
5. Mantenha-se atualizado com papers e conferências
Links Importantes
Documentação oficial: https://scikit-learn.org/ (https://scikit-learn.org/)
TensorFlow: https://www.tensorflow.org/ (https://www.tensorflow.org/)
Kaggle Learn: https://www.kaggle.com/learn (https://www.kaggle.com/learn)
Papers with Code: https://paperswithcode.com/ (https://paperswithcode.com/)
Nota: Este guia fornece uma base sólida para começar com IA em Python. A prática constante e a experimentação são
fundamentais para o desenvolvimento de habilidades avançadas na área.
