Configuração de ambientes de desenvolvimento para AI/ML

1. Fundamentos da Infraestrutura para AI/ML

A escolha da infraestrutura para desenvolvimento em AI/ML depende diretamente da escala do projeto e dos recursos disponíveis. Ambientes locais são ideais para prototipação rápida, enquanto clouds como AWS, GCP e Azure oferecem escalabilidade elástica para treinamento de modelos complexos. Soluções híbridas combinam desenvolvimento local com execução remota em clusters.

Requisitos de hardware essenciais:
- GPU NVIDIA com CUDA: pelo menos 8GB VRAM para modelos pequenos, 24GB+ para transformers
- RAM: mínimo 16GB (32GB recomendado para datasets médios)
- Armazenamento SSD NVMe: 512GB+ para datasets e checkpoints

Sistemas operacionais recomendados:
- Linux Ubuntu 22.04 LTS (melhor suporte a drivers NVIDIA)
- Windows com WSL2 (Ubuntu distro) para compatibilidade com ferramentas nativas
- macOS (Apple Silicon com Metal Performance Shaders para PyTorch)

# Verificação de hardware no Ubuntu
lspci | grep -i nvidia
nvidia-smi --query-gpu=name,memory.total --format=csv
free -h
df -h | grep ssd

2. Gerenciamento de Ambientes e Dependências

O isolamento de ambientes é crítico para evitar conflitos entre versões de bibliotecas. Conda (via Miniconda) gerencia pacotes binários e Python, enquanto Docker oferece isolamento completo do sistema operacional.

Configuração com Conda:

# Instalação do Miniconda
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh

# Criação de ambiente com Python 3.10 e CUDA
conda create -n ml_env python=3.10
conda activate ml_env
conda install -c conda-forge cudatoolkit=11.8 cudnn=8.6

Gerenciamento de dependências com requirements.txt:

# requirements.txt
tensorflow==2.13.0
torch==2.1.0
scikit-learn==1.3.2
xgboost==2.0.0
pandas==2.1.3
numpy==1.24.3
matplotlib==3.8.0
jupyter==1.0.0
dvc==3.15.0
mlflow==2.7.1

# Instalação
pip install -r requirements.txt

Docker para reprodutibilidade:

# Dockerfile para AI/ML
FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04

RUN apt-get update && apt-get install -y \
    python3.10 python3-pip git curl \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /workspace
COPY requirements.txt .
RUN pip3 install --no-cache-dir -r requirements.txt

CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--no-browser"]

3. Instalação e Configuração de Frameworks Principais

TensorFlow com suporte GPU:

# Verificar compatibilidade CUDA
conda install -c conda-forge cudatoolkit=11.8 cudnn=8.6
pip install tensorflow==2.13.0

# Testar GPU
python -c "import tensorflow as tf; print('GPU disponível:', tf.config.list_physical_devices('GPU'))"

PyTorch otimizado:

# Para CUDA 11.8
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# Para ROCm (AMD GPUs)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm5.6

# Verificar dispositivo
python -c "import torch; print('CUDA disponível:', torch.cuda.is_available()); print('Dispositivo:', torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU')"

Scikit-learn e XGBoost:

pip install scikit-learn==1.3.2 xgboost==2.0.0

# Configuração XGBoost para GPU
import xgboost as xgb
params = {'tree_method': 'hist', 'device': 'cuda'}

4. Ferramentas de Desenvolvimento e Versionamento

Jupyter Lab com extensões:

# Instalação e configuração
pip install jupyterlab jupyterlab-git jupyter-tensorboard
jupyter lab --generate-config

# Configuração de senha
jupyter notebook password

VS Code com extensões essenciais:

# Extensões recomendadas:
# - Python (ms-python.python)
# - Jupyter (ms-toolsai.jupyter)
# - Docker (ms-azuretools.vscode-docker)
# - GitLens (eamodio.gitlens)
# - GitHub Copilot (GitHub.copilot)

Versionamento com DVC e MLflow:

# Inicializar DVC
dvc init
dvc remote add -d myremote s3://my-bucket/dvc-store

# Rastrear datasets
dvc add data/raw/dataset.csv
git add data/raw/dataset.csv.dvc .gitignore

# Configurar MLflow
mlflow server --host 0.0.0.0 --port 5000

# Exemplo de tracking
import mlflow
mlflow.set_tracking_uri("http://localhost:5000")
with mlflow.start_run():
    mlflow.log_param("learning_rate", 0.01)
    mlflow.log_metric("accuracy", 0.95)
    mlflow.pytorch.log_model(model, "model")

5. Otimização de Performance e Debug

Monitoramento de GPU:

# Monitoramento contínuo
watch -n 1 nvidia-smi

# Uso em Python
import subprocess
def get_gpu_usage():
    result = subprocess.run(['nvidia-smi', '--query-gpu=utilization.gpu,memory.used', '--format=csv'], 
                          capture_output=True, text=True)
    return result.stdout

# TensorBoard para tracking
tensorboard --logdir ./logs --port 6006

Cache e pré-processamento eficiente:

# Cache de datasets com PyTorch
from torch.utils.data import DataLoader, Dataset
import pandas as pd

class CachedDataset(Dataset):
    def __init__(self, csv_path):
        self.data = pd.read_csv(csv_path)
        self.cache = {}

    def __getitem__(self, idx):
        if idx not in self.cache:
            self.cache[idx] = self.data.iloc[idx].values
        return self.cache[idx]

# Pré-processamento paralelo
import multiprocessing as mp
with mp.Pool(processes=mp.cpu_count()) as pool:
    results = pool.map(process_function, data_chunks)

Debug de memória:

pip install memory_profiler psutil

# Uso em script
from memory_profiler import profile
@profile
def train_model():
    # código do treinamento
    pass

# Monitoramento em tempo real
import psutil
def log_memory():
    process = psutil.Process()
    print(f"Memory: {process.memory_info().rss / 1024**2:.2f} MB")

6. Integração com CI/CD e Orquestração

Pipeline com GitHub Actions:

# .github/workflows/ml_pipeline.yml
name: ML Pipeline
on: [push]
jobs:
  train:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.10'
    - name: Install dependencies
      run: pip install -r requirements.txt
    - name: Train model
      run: python train.py
    - name: Upload artifacts
      uses: actions/upload-artifact@v3
      with:
        name: model
        path: model.pkl

Orquestração com Airflow:

# DAG para treinamento
from airflow import DAG
from airflow.operators.python import PythonOperator
from datetime import datetime

def train_model_task():
    import subprocess
    subprocess.run(["python", "train.py"])

with DAG('ml_training', start_date=datetime(2024,1,1), schedule_interval='@weekly') as dag:
    train = PythonOperator(
        task_id='train_model',
        python_callable=train_model_task
    )

Deploy com TensorFlow Serving:

# Docker compose para serving
version: '3'
services:
  tf_serving:
    image: tensorflow/serving:2.13.0-gpu
    ports:
      - "8501:8501"
    volumes:
      - ./models:/models
    environment:
      - MODEL_NAME=my_model

7. Segurança e Boas Práticas

Gerenciamento de chaves:

# .env file
API_KEY=sk-xxxxxxxxxxxxxxxx
AWS_ACCESS_KEY_ID=AKIAXXXXXXXX
AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxx

# Uso em Python
from dotenv import load_dotenv
import os
load_dotenv()
api_key = os.getenv('API_KEY')

Controle de acesso a datasets:

# Configuração de permissões
chmod 600 data/sensitive_dataset.csv
chmod 700 experiments/

# Logs de experimentos com MLflow
mlflow.set_experiment("production_experiment")
mlflow.set_tag("access_level", "restricted")

Checklist de reprodução:

# environment_checklist.sh
#!/bin/bash
echo "=== Checklist de Ambiente ==="
python --version
pip list | grep -E "tensorflow|torch|scikit-learn|xgboost"
nvidia-smi
docker --version
conda info --envs
dvc --version
mlflow --version

Referências