Deep Q-Networks (DQN): aproximando funções com redes neurais

html

4.2 – Metodos Baseados em Valor
4.2.4 – Aproximacao de Funcoes
4.2.4.1 – Deep Q-Networks – DQN

LEGENDA

Principal

Ramo

Metodo

Problemas

Modelo

Arquitetura

O DQN combina Q-Learning com redes neurais profundas. Primeiramente, ele resolve o problema de espaços de estados contínuos. Tabelas Q não funcionam quando há milhões de estados. Em segundo lugar, a rede neural aproxima a função Q(s,a). Por conseguinte, o DQN aprende a jogar jogos vendo apenas pixels. Esta foi uma revolução no aprendizado por reforço.

Características da arquitetura DQN

A arquitetura usa duas redes neurais principais. A rede online é atualizada a cada passo. A rede alvo (target) é atualizada lentamente. Isso estabiliza o treinamento. Além disso, o DQN usa replay de experiência (experience replay). Transições são armazenadas em um buffer. Amostras aleatórias quebram correlações entre experiências. Consequentemente, o aprendizado é mais estável e eficiente.

A rede online tem parâmetros θ. A rede alvo tem parâmetros θ⁻. A perda é calculada como \( L(θ) = \mathbb{E}[(r + \gamma \max_{a’} Q(s’,a’;θ^-) – Q(s,a;θ))^2] \). O gradiente descendente é aplicado apenas à rede online. A rede alvo é atualizada por cópia suave (soft update): \( θ^- \leftarrow τθ + (1-τ)θ^- \). Ou usamos hard update a cada C passos.

Hiperparâmetros e fórmulas matemáticas

Os hiperparâmetros do DQN são críticos para convergência. A taxa de aprendizado α tipicamente é 0.00025. O fator de desconto γ é 0.99. O buffer de replay armazena 1 milhão de transições. O tamanho do batch é 32 ou 64. A frequência de atualização da rede alvo é 10000 passos. A exploração usa ε-greedy com decaimento de 1.0 para 0.1. O erro TD é \( \delta = r + \gamma \max_{a’} Q(s’,a’;θ^-) – Q(s,a;θ) \). A perda é o erro quadrático médio.

O DQN original foi aplicado a jogos da Atari. Ele aprendeu a jogar Breakout, Pong e Space Invaders. A entrada era imagens de 84×84 pixels em escala de cinza. A rede tinha três camadas convolucionais e duas densas. O desempenho superou humanos em vários jogos. DQN é considerado um marco histórico em IA.

Exemplo clássico: ambiente CartPole

Considere o ambiente CartPole do OpenAI Gym. Um carrinho deve equilibrar uma haste na vertical. O estado é contínuo (posição, velocidade, ângulo). As ações são discretas (esquerda ou direita). O DQN aproxima Q(s,a) com uma rede neural. O código abaixo implementa DQN para resolver CartPole. Ele mostra gráficos de recompensa e perda durante o treinamento.

import numpy as np
import matplotlib.pyplot as plt
import random
from collections import deque
import time
from tqdm import tqdm

# Tentar importar gym, instalar se necessário
try:
    import gym
except ImportError:
    import subprocess
    subprocess.check_call(['pip', 'install', 'gym'])
    import gym

import warnings
warnings.filterwarnings('ignore')

print("=" * 70)
print("DEEP Q-NETWORK (DQN) - CART POLE")
print("=" * 70)

# ============================================
# REDE NEURAL DO DQN (USANDO NUMPY + PYTORCH LIGHT)
# ============================================

# Verifica se tem PyTorch, senão instala
try:
    import torch
    import torch.nn as nn
    import torch.optim as optim
    USE_PYTORCH = True
    print("✅ Usando PyTorch para a rede neural")
except ImportError:
    print("⚠️ PyTorch não encontrado, instalando...")
    import subprocess
    subprocess.check_call(['pip', 'install', 'torch'])
    import torch
    import torch.nn as nn
    import torch.optim as optim
    USE_PYTORCH = True

class RedeDQN(nn.Module):
    """Rede neural para aproximar Q(s,a)"""
    def __init__(self, n_entradas, n_saidas):
        super(RedeDQN, self).__init__()
        self.fc1 = nn.Linear(n_entradas, 24)
        self.fc2 = nn.Linear(24, 24)
        self.fc3 = nn.Linear(24, n_saidas)
        
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

# ============================================
# AGENTE DQN
# ============================================

class DQNAgente:
    """Agente Deep Q-Network com replay buffer e target network"""
    
    def __init__(self, n_estados, n_acoes, gamma=0.95, epsilon=1.0, epsilon_min=0.01, 
                 epsilon_decay=0.995, learning_rate=0.001, batch_size=32,
                 memoria_tamanho=2000, tau=0.01, device='cpu'):
        
        self.n_estados = n_estados
        self.n_acoes = n_acoes
        self.gamma = gamma
        self.epsilon = epsilon
        self.epsilon_min = epsilon_min
        self.epsilon_decay = epsilon_decay
        self.batch_size = batch_size
        self.tau = tau
        self.device = device
        
        # Redes neurais
        self.model = RedeDQN(n_estados, n_acoes).to(device)
        self.target_model = RedeDQN(n_estados, n_acoes).to(device)
        self.optimizer = optim.Adam(self.model.parameters(), lr=learning_rate)
        
        # Copia pesos iniciais
        self.atualizar_target()
        
        # Memória de replay
        self.memoria = deque(maxlen=memoria_tamanho)
        
        # Histórico
        self.losses = []
        
    def atualizar_target(self):
        """Hard update: copia pesos da rede online para target"""
        self.target_model.load_state_dict(self.model.state_dict())
    
    def soft_update_target(self):
        """Soft update: atualiza target gradualmente"""
        for target_param, online_param in zip(self.target_model.parameters(), self.model.parameters()):
            target_param.data.copy_(self.tau * online_param.data + (1 - self.tau) * target_param.data)
    
    def lembrar(self, estado, acao, recompensa, prox_estado, terminou):
        """Armazena transição na memória"""
        self.memoria.append((estado, acao, recompensa, prox_estado, terminou))
    
    def escolher_acao(self, estado):
        """Política ε-greedy"""
        if np.random.random() < self.epsilon:
            return random.randrange(self.n_acoes)
        
        estado_tensor = torch.FloatTensor(estado).unsqueeze(0).to(self.device)
        with torch.no_grad():
            q_vals = self.model(estado_tensor).cpu().numpy()[0]
        return np.argmax(q_vals)
    
    def replay(self):
        """Treina rede com amostras aleatórias da memória"""
        if len(self.memoria) < self.batch_size:
            return 0
        
        # Amostra batch aleatório
        batch = random.sample(self.memoria, self.batch_size)
        
        estados = []
        alvos = []
        
        for estado, acao, recompensa, prox_estado, terminou in batch:
            estado_tensor = torch.FloatTensor(estado).unsqueeze(0).to(self.device)
            q_atual = self.model(estado_tensor).cpu().detach().numpy()[0]
            
            if terminou:
                q_atual[acao] = recompensa
            else:
                prox_estado_tensor = torch.FloatTensor(prox_estado).unsqueeze(0).to(self.device)
                with torch.no_grad():
                    q_futuro = self.target_model(prox_estado_tensor).cpu().numpy()[0]
                q_atual[acao] = recompensa + self.gamma * np.max(q_futuro)
            
            estados.append(estado)
            alvos.append(q_atual)
        
        # Converte para tensores
        estados_tensor = torch.FloatTensor(np.array(estados)).to(self.device)
        alvos_tensor = torch.FloatTensor(np.array(alvos)).to(self.device)
        
        # Calcula perda e atualiza
        self.optimizer.zero_grad()
        saidas = self.model(estados_tensor)
        loss = nn.MSELoss()(saidas, alvos_tensor)
        loss.backward()
        self.optimizer.step()
        
        # Soft update da target network
        self.soft_update_target()
        
        self.losses.append(loss.item())
        return loss.item()
    
    def decair_epsilon(self):
        """Reduz exploração gradualmente"""
        self.epsilon = max(self.epsilon_min, self.epsilon * self.epsilon_decay)

# ============================================
# FUNÇÃO PARA RESET DO AMBIENTE (COMPATÍVEL)
# ============================================

def reset_env(env):
    """Compatível com diferentes versões do Gym"""
    resultado = env.reset()
    if isinstance(resultado, (tuple, list)):
        return resultado[0]
    return resultado

def step_env(env, acao):
    """Compatível com diferentes versões do Gym"""
    resultado = env.step(acao)
    if len(resultado) == 4:
        return resultado[0], resultado[1], resultado[2], resultado[3]
    else:
        return resultado[0], resultado[1], resultado[2], resultado[3]

# ============================================
# TREINAMENTO
# ============================================

print("\n" + "=" * 70)
print("TREINAMENTO DO DQN NO CART POLE")
print("=" * 70)

# Cria ambiente
env = gym.make('CartPole-v1')
n_acoes = env.action_space.n
n_estados = env.observation_space.shape[0]

print(f"\n📊 Ambiente CartPole:")
print(f"   - Estados: {n_estados} (posição, velocidade, ângulo, velocidade angular)")
print(f"   - Ações: {n_acoes} (0=esquerda, 1=direita)")
print(f"   - Objetivo: equilibrar a haste por 500 passos")

# Dispositivo
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f"   - Dispositivo: {device}")

# Hiperparâmetros
episodios = 500
passos_maximos = 500

# Inicializa agente
agente = DQNAgente(
    n_estados=n_estados,
    n_acoes=n_acoes,
    gamma=0.95,
    epsilon=1.0,
    epsilon_min=0.01,
    epsilon_decay=0.995,
    learning_rate=0.001,
    batch_size=32,
    memoria_tamanho=2000,
    tau=0.01,
    device=device
)

# Armazena métricas
recompensas_episodio = []
passos_por_episodio = []
losses_episodio = []

print("\n🚀 Treinando DQN...\n")

with tqdm(total=episodios, desc="Episódios", unit="ep",
          ncols=80, mininterval=0.5, bar_format='{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]') as pbar:
    
    for ep in range(episodios):
        estado = reset_env(env)
        recompensa_total = 0
        passos = 0
        loss_ep = []
        
        for passo in range(passos_maximos):
            acao = agente.escolher_acao(estado)
            prox_estado, recompensa, terminou, _ = step_env(env, acao)
            
            agente.lembrar(estado, acao, recompensa, prox_estado, terminou)
            
            estado = prox_estado
            recompensa_total += recompensa
            passos += 1
            
            # Treina a cada 4 passos
            if passo % 4 == 0:
                loss = agente.replay()
                if loss > 0:
                    loss_ep.append(loss)
            
            if terminou:
                break
        
        recompensas_episodio.append(recompensa_total)
        passos_por_episodio.append(passos)
        if loss_ep:
            losses_episodio.append(np.mean(loss_ep))
        else:
            losses_episodio.append(0)
        
        agente.decair_epsilon()
        
        # Atualiza barra
        if (ep + 1) % 10 == 0:
            media_recomp = np.mean(recompensas_episodio[-10:])
            pbar.set_postfix({'Recomp': f'{media_recomp:.1f}', 'ε': f'{agente.epsilon:.3f}'})
            pbar.update(10)
        elif ep == 0:
            pbar.update(1)

print("\n✅ Treinamento concluído!")

# ============================================
# AVALIAÇÃO DO AGENTE
# ============================================

print("\n" + "=" * 70)
print("AVALIAÇÃO DO AGENTE TREINADO")
print("=" * 70)

def avaliar_agente(agente, n_testes=20):
    """Avalia o agente sem exploração"""
    recompensas_teste = []
    epsilon_original = agente.epsilon
    agente.epsilon = 0  # Desliga exploração
    
    with tqdm(total=n_testes, desc="Testando", unit="teste", ncols=80) as pbar:
        for ep in range(n_testes):
            estado = reset_env(env)
            recompensa_total = 0
            terminou = False
            
            while not terminou:
                acao = agente.escolher_acao(estado)
                estado, recompensa, terminou, _ = step_env(env, acao)
                recompensa_total += recompensa
            
            recompensas_teste.append(recompensa_total)
            pbar.update(1)
    
    agente.epsilon = epsilon_original
    media = np.mean(recompensas_teste)
    
    print(f"\n🏆 Média de recompensa em {n_testes} testes: {media:.1f}")
    print(f"   (Objetivo máximo: 500.0)")
    
    if media >= 475:
        print("   ✅ Agente resolveu o CartPole!")
    elif media >= 400:
        print("   👍 Bom desempenho, pode melhorar")
    else:
        print("   ⚠️  Precisa de mais treinamento")
    
    return media

media_teste = avaliar_agente(agente)

# ============================================
# VISUALIZAÇÃO DOS RESULTADOS
# ============================================

print("\n📊 Gerando gráficos...")

plt.figure(figsize=(14, 5))

# Gráfico 1: Evolução das recompensas
plt.subplot(1, 2, 1)
plt.plot(recompensas_episodio, 'b-', linewidth=0.5, alpha=0.5, label='Recompensa')
window = 20
if len(recompensas_episodio) >= window:
    media_recomp = np.convolve(recompensas_episodio, np.ones(window)/window, mode='valid')
    plt.plot(media_recomp, 'r-', linewidth=2, label=f'Média {window}')
plt.xlabel('Episódio')
plt.ylabel('Recompensa (passos sobreviventes)')
plt.title('DQN: Aprendizado no CartPole')
plt.legend()
plt.grid(True, alpha=0.3)
plt.axhline(y=475, color='g', linestyle='--', label='Solução (475+)')
plt.legend()

# Gráfico 2: Perda (loss) do treinamento
plt.subplot(1, 2, 2)
if len(losses_episodio) >= window:
    losses_smooth = np.convolve(losses_episodio, np.ones(window)/window, mode='valid')
    plt.plot(losses_smooth, 'purple', linewidth=2)
else:
    plt.plot(losses_episodio, 'purple', linewidth=1)
plt.xlabel('Episódio')
plt.ylabel('Perda (MSE)')
plt.title('Evolução da Perda da Rede Neural')
plt.grid(True, alpha=0.3)
plt.yscale('log')

plt.tight_layout()
plt.show()

# ============================================
# VISUALIZAÇÃO DA POLÍTICA
# ============================================

print("\n📊 Analisando a política aprendida...")

# Testa política em diferentes estados
estados_teste = [
    [0.0, 0.0, 0.0, 0.0],    # centro, parado
    [0.5, 0.0, 0.0, 0.0],    # deslocado para direita
    [-0.5, 0.0, 0.0, 0.0],   # deslocado para esquerda
    [0.0, 1.0, 0.0, 0.0],    # movendo para direita
    [0.0, -1.0, 0.0, 0.0],   # movendo para esquerda
    [0.0, 0.0, 0.2, 0.0],    # inclinado
    [0.0, 0.0, -0.2, 0.0],   # inclinado negativo
]

print("\n   Estado (pos, vel, ang, vel_ang) → Ação escolhida")
print("   " + "-" * 55)
for estado in estados_teste:
    acao = agente.escolher_acao(estado)
    nome_acao = "DIREITA" if acao == 1 else "ESQUERDA"
    print(f"   ({estado[0]:.2f}, {estado[1]:.2f}, {estado[2]:.2f}, {estado[3]:.2f}) → {nome_acao}")

# ============================================
# COMPARAÇÃO COM Q-LEARNING TABULAR
# ============================================

print("\n" + "=" * 70)
print("POR QUE DQN É NECESSÁRIO?")
print("=" * 70)

print("""
✅ PROBLEMA COM TABELAS Q:

No CartPole, o espaço de estados é CONTÍNUO!
• Posição: valor real entre -2.4 e 2.4 (infinitos valores)
• Velocidade: valor real entre -3 e 3
• Ângulo: valor real entre -0.42 e 0.42
• Velocidade angular: valor real entre -3 e 3

Uma tabela Q precisaria discretizar cada dimensão.
Com apenas 10 divisões por dimensão: 10⁴ = 10.000 estados
Com 100 divisões: 100⁴ = 100 MILHÕES de estados!
Isso é inviável.

✅ SOLUÇÃO DO DQN:

A rede neural aprende a GENERALIZAR!
Ela mapeia estados contínuos diretamente para valores Q.
Sem discretização, sem explosão combinatória.

✅ TAMANHO DA REDE USADA:
• 4 entradas (estado contínuo)
• 2 camadas ocultas com 24 neurônios cada
• 2 saídas (Q para esquerda e direita)
Total de parâmetros: ~1.200 (muito menor que uma tabela!)
""")

# ============================================
# EXPLICAÇÃO MATEMÁTICA
# ============================================

print("\n" + "=" * 70)
print("FUNDAMENTOS DO DEEP Q-NETWORK (DQN)")
print("=" * 70)

print("""
✅ O PROBLEMA QUE O DQN RESOLVE:

Em espaços de estados contínuos, tabelas Q são inviáveis.
O número de estados cresce exponencialmente com dimensões.

✅ APROXIMAÇÃO DE FUNÇÕES:

Usamos uma rede neural Q(s,a; θ) para aproximar Q*(s,a).
θ são os pesos da rede (milhares, não milhões de parâmetros).

✅ FUNÇÃO DE PERDA DO DQN:

[latex] L(θ) = \\mathbb{E}_{(s,a,r,s') \\sim U(D)} [(r + \\gamma \\max_{a'} Q(s',a';θ^-) - Q(s,a;θ))^2] [/latex]

Onde:
- D é o buffer de replay (experience replay)
- θ⁻ são parâmetros da rede alvo (target network)
- U(D) é amostragem uniforme do buffer

✅ COMPONENTES CRÍTICOS DO DQN:

1. REPLAY BUFFER:
   Armazena últimas N transições (s, a, r, s').
   Amostragem aleatória quebra correlações temporais.

2. TARGET NETWORK:
   Rede separada com parâmetros congelados θ⁻.
   Atualizada a cada C passos (hard) ou via soft update.
   Estabiliza o treinamento evitando alvos móveis.

3. ε-GREEDY COM DECAIMENTO:
   Alta exploração no início, explotação no final.

✅ HIPERPARÂMETROS TÍPICOS:

• γ = 0.95 a 0.99 (fator de desconto)
• α = 0.00025 (taxa aprendizado - Adam)
• ε inicial = 1.0, ε final = 0.01
• ε decay = 0.995 (multiplicativo)
• Buffer size = 1.000.000 (para Atari)
• Batch size = 32 a 64
• Target update = 10.000 passos (hard) ou τ=0.001 (soft)
""")

print("\n" + "=" * 70)
print("CONCLUSÃO")
print("=" * 70)

print(f"""
✅ DQN é um marco histórico no aprendizado por reforço.
✅ Ele combina Q-Learning, redes neurais, replay buffer e target network.
✅ O agente aprendeu a equilibrar o CartPole em {episodios} episódios.
✅ A média final de recompensa foi {media_teste:.1f} (máximo 500).

RESULTADOS:
• Recompensa máxima obtida: {max(recompensas_episodio):.0f}
• Recompensa média (últimos 50): {np.mean(recompensas_episodio[-50:]):.1f}
• Epsilon final: {agente.epsilon:.3f}
• Tamanho da memória: {len(agente.memoria)}

O DQN foi usado para jogar Atari, superando humanos em vários jogos!
""")

print("\n✅ PROGRAMA CONCLUÍDO COM SUCESSO!")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

import numpy as np

import matplotlib.pyplot as plt

import random

from collections import deque

import time

from tqdm import tqdm

# Tentar importar gym, instalar se necessário

try:

import gym

except ImportError:

import subprocess

subprocess.check_call(['pip', 'install', 'gym'])

import gym

import warnings

warnings.filterwarnings('ignore')

print("=" * 70)

print("DEEP Q-NETWORK (DQN) - CART POLE")

print("=" * 70)

# ============================================

# REDE NEURAL DO DQN (USANDO NUMPY + PYTORCH LIGHT)

# ============================================

# Verifica se tem PyTorch, senão instala

try:

import torch

import torch.nn as nn

import torch.optim as optim

USE_PYTORCH = True

print("✅ Usando PyTorch para a rede neural")

except ImportError:

print("⚠️ PyTorch não encontrado, instalando...")

import subprocess

subprocess.check_call(['pip', 'install', 'torch'])

import torch

import torch.nn as nn

import torch.optim as optim

USE_PYTORCH = True

class RedeDQN(nn.Module):

"""Rede neural para aproximar Q(s,a)"""

def __init__(self, n_entradas, n_saidas):

super(RedeDQN, self).__init__()

self.fc1 = nn.Linear(n_entradas, 24)

self.fc2 = nn.Linear(24, 24)

self.fc3 = nn.Linear(24, n_saidas)

def forward(self, x):

x = torch.relu(self.fc1(x))

x = torch.relu(self.fc2(x))

return self.fc3(x)

# ============================================

# AGENTE DQN

# ============================================

class DQNAgente:

"""Agente Deep Q-Network com replay buffer e target network"""

def __init__(self, n_estados, n_acoes, gamma=0.95, epsilon=1.0, epsilon_min=0.01,

epsilon_decay=0.995, learning_rate=0.001, batch_size=32,

memoria_tamanho=2000, tau=0.01, device='cpu'):

self.n_estados = n_estados

self.n_acoes = n_acoes

self.gamma = gamma

self.epsilon = epsilon

self.epsilon_min = epsilon_min

self.epsilon_decay = epsilon_decay

self.batch_size = batch_size

self.tau = tau

self.device = device

# Redes neurais

self.model = RedeDQN(n_estados, n_acoes).to(device)

self.target_model = RedeDQN(n_estados, n_acoes).to(device)

self.optimizer = optim.Adam(self.model.parameters(), lr=learning_rate)

# Copia pesos iniciais

self.atualizar_target()

# Memória de replay

self.memoria = deque(maxlen=memoria_tamanho)

# Histórico

self.losses = []

def atualizar_target(self):

"""Hard update: copia pesos da rede online para target"""

self.target_model.load_state_dict(self.model.state_dict())

def soft_update_target(self):

"""Soft update: atualiza target gradualmente"""

for target_param, online_param in zip(self.target_model.parameters(), self.model.parameters()):

target_param.data.copy_(self.tau * online_param.data + (1 - self.tau) * target_param.data)

def lembrar(self, estado, acao, recompensa, prox_estado, terminou):

"""Armazena transição na memória"""

self.memoria.append((estado, acao, recompensa, prox_estado, terminou))

def escolher_acao(self, estado):

"""Política ε-greedy"""

if np.random.random() < self.epsilon:

return random.randrange(self.n_acoes)

estado_tensor = torch.FloatTensor(estado).unsqueeze(0).to(self.device)

with torch.no_grad():

q_vals = self.model(estado_tensor).cpu().numpy()[0]

return np.argmax(q_vals)

def replay(self):

"""Treina rede com amostras aleatórias da memória"""

if len(self.memoria) < self.batch_size:

return 0

# Amostra batch aleatório

batch = random.sample(self.memoria, self.batch_size)

estados = []

alvos = []

for estado, acao, recompensa, prox_estado, terminou in batch:

estado_tensor = torch.FloatTensor(estado).unsqueeze(0).to(self.device)

q_atual = self.model(estado_tensor).cpu().detach().numpy()[0]

if terminou:

q_atual[acao] = recompensa

else:

prox_estado_tensor = torch.FloatTensor(prox_estado).unsqueeze(0).to(self.device)

with torch.no_grad():

q_futuro = self.target_model(prox_estado_tensor).cpu().numpy()[0]

q_atual[acao] = recompensa + self.gamma * np.max(q_futuro)

estados.append(estado)

alvos.append(q_atual)

# Converte para tensores

estados_tensor = torch.FloatTensor(np.array(estados)).to(self.device)

alvos_tensor = torch.FloatTensor(np.array(alvos)).to(self.device)

# Calcula perda e atualiza

self.optimizer.zero_grad()

saidas = self.model(estados_tensor)

loss = nn.MSELoss()(saidas, alvos_tensor)

loss.backward()

self.optimizer.step()

# Soft update da target network

self.soft_update_target()

self.losses.append(loss.item())

return loss.item()

def decair_epsilon(self):

"""Reduz exploração gradualmente"""

self.epsilon = max(self.epsilon_min, self.epsilon * self.epsilon_decay)

# ============================================

# FUNÇÃO PARA RESET DO AMBIENTE (COMPATÍVEL)

# ============================================

def reset_env(env):

"""Compatível com diferentes versões do Gym"""

resultado = env.reset()

if isinstance(resultado, (tuple, list)):

return resultado[0]

return resultado

def step_env(env, acao):

"""Compatível com diferentes versões do Gym"""

resultado = env.step(acao)

if len(resultado) == 4:

return resultado[0], resultado[1], resultado[2], resultado[3]

else:

return resultado[0], resultado[1], resultado[2], resultado[3]

# ============================================

# TREINAMENTO

# ============================================

print("\n" + "=" * 70)

print("TREINAMENTO DO DQN NO CART POLE")

print("=" * 70)

# Cria ambiente

env = gym.make('CartPole-v1')

n_acoes = env.action_space.n

n_estados = env.observation_space.shape[0]

print(f"\n📊 Ambiente CartPole:")

print(f" - Estados: {n_estados} (posição, velocidade, ângulo, velocidade angular)")

print(f" - Ações: {n_acoes} (0=esquerda, 1=direita)")

print(f" - Objetivo: equilibrar a haste por 500 passos")

# Dispositivo

device = 'cuda' if torch.cuda.is_available() else 'cpu'

print(f" - Dispositivo: {device}")

# Hiperparâmetros

episodios = 500

passos_maximos = 500

# Inicializa agente

agente = DQNAgente(

n_estados=n_estados,

n_acoes=n_acoes,

gamma=0.95,

epsilon=1.0,

epsilon_min=0.01,

epsilon_decay=0.995,

learning_rate=0.001,

batch_size=32,

memoria_tamanho=2000,

tau=0.01,

device=device

)

# Armazena métricas

recompensas_episodio = []

passos_por_episodio = []

losses_episodio = []

print("\n🚀 Treinando DQN...\n")

with tqdm(total=episodios, desc="Episódios", unit="ep",

ncols=80, mininterval=0.5, bar_format='{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]') as pbar:

for ep in range(episodios):

estado = reset_env(env)

recompensa_total = 0

passos = 0

loss_ep = []

for passo in range(passos_maximos):

acao = agente.escolher_acao(estado)

prox_estado, recompensa, terminou, _ = step_env(env, acao)

agente.lembrar(estado, acao, recompensa, prox_estado, terminou)

estado = prox_estado

recompensa_total += recompensa

passos += 1

# Treina a cada 4 passos

if passo % 4 == 0:

loss = agente.replay()

if loss > 0:

loss_ep.append(loss)

if terminou:

break

recompensas_episodio.append(recompensa_total)

passos_por_episodio.append(passos)

if loss_ep:

losses_episodio.append(np.mean(loss_ep))

else:

losses_episodio.append(0)

agente.decair_epsilon()

# Atualiza barra

if (ep + 1) % 10 == 0:

media_recomp = np.mean(recompensas_episodio[-10:])

pbar.set_postfix({'Recomp': f'{media_recomp:.1f}', 'ε': f'{agente.epsilon:.3f}'})

pbar.update(10)

elif ep == 0:

pbar.update(1)

print("\n✅ Treinamento concluído!")

# ============================================

# AVALIAÇÃO DO AGENTE

# ============================================

print("\n" + "=" * 70)

print("AVALIAÇÃO DO AGENTE TREINADO")

print("=" * 70)

def avaliar_agente(agente, n_testes=20):

"""Avalia o agente sem exploração"""

recompensas_teste = []

epsilon_original = agente.epsilon

agente.epsilon = 0 # Desliga exploração

with tqdm(total=n_testes, desc="Testando", unit="teste", ncols=80) as pbar:

for ep in range(n_testes):

estado = reset_env(env)

recompensa_total = 0

terminou = False

while not terminou:

acao = agente.escolher_acao(estado)

estado, recompensa, terminou, _ = step_env(env, acao)

recompensa_total += recompensa

recompensas_teste.append(recompensa_total)

pbar.update(1)

agente.epsilon = epsilon_original

media = np.mean(recompensas_teste)

print(f"\n🏆 Média de recompensa em {n_testes} testes: {media:.1f}")

print(f" (Objetivo máximo: 500.0)")

if media >= 475:

print(" ✅ Agente resolveu o CartPole!")

elif media >= 400:

print(" 👍 Bom desempenho, pode melhorar")

else:

print(" ⚠️ Precisa de mais treinamento")

return media

media_teste = avaliar_agente(agente)

# ============================================

# VISUALIZAÇÃO DOS RESULTADOS

# ============================================

print("\n📊 Gerando gráficos...")

plt.figure(figsize=(14, 5))

# Gráfico 1: Evolução das recompensas

plt.subplot(1, 2, 1)

plt.plot(recompensas_episodio, 'b-', linewidth=0.5, alpha=0.5, label='Recompensa')

window = 20

if len(recompensas_episodio) >= window:

media_recomp = np.convolve(recompensas_episodio, np.ones(window)/window, mode='valid')

plt.plot(media_recomp, 'r-', linewidth=2, label=f'Média {window}')

plt.xlabel('Episódio')

plt.ylabel('Recompensa (passos sobreviventes)')

plt.title('DQN: Aprendizado no CartPole')

plt.legend()

plt.grid(True, alpha=0.3)

plt.axhline(y=475, color='g', linestyle='--', label='Solução (475+)')

plt.legend()

# Gráfico 2: Perda (loss) do treinamento

plt.subplot(1, 2, 2)

if len(losses_episodio) >= window:

losses_smooth = np.convolve(losses_episodio, np.ones(window)/window, mode='valid')

plt.plot(losses_smooth, 'purple', linewidth=2)

else:

plt.plot(losses_episodio, 'purple', linewidth=1)

plt.xlabel('Episódio')

plt.ylabel('Perda (MSE)')

plt.title('Evolução da Perda da Rede Neural')

plt.grid(True, alpha=0.3)

plt.yscale('log')

plt.tight_layout()

plt.show()

# ============================================

# VISUALIZAÇÃO DA POLÍTICA

# ============================================

print("\n📊 Analisando a política aprendida...")

# Testa política em diferentes estados

estados_teste = [

[0.0, 0.0, 0.0, 0.0], # centro, parado

[0.5, 0.0, 0.0, 0.0], # deslocado para direita

[-0.5, 0.0, 0.0, 0.0], # deslocado para esquerda

[0.0, 1.0, 0.0, 0.0], # movendo para direita

[0.0, -1.0, 0.0, 0.0], # movendo para esquerda

[0.0, 0.0, 0.2, 0.0], # inclinado

[0.0, 0.0, -0.2, 0.0], # inclinado negativo

]

print("\n Estado (pos, vel, ang, vel_ang) → Ação escolhida")

print(" " + "-" * 55)

for estado in estados_teste:

acao = agente.escolher_acao(estado)

nome_acao = "DIREITA" if acao == 1 else "ESQUERDA"

print(f" ({estado[0]:.2f}, {estado[1]:.2f}, {estado[2]:.2f}, {estado[3]:.2f}) → {nome_acao}")

# ============================================

# COMPARAÇÃO COM Q-LEARNING TABULAR

# ============================================

print("\n" + "=" * 70)

print("POR QUE DQN É NECESSÁRIO?")

print("=" * 70)

print("""

✅ PROBLEMA COM TABELAS Q:

No CartPole, o espaço de estados é CONTÍNUO!

• Posição: valor real entre -2.4 e 2.4 (infinitos valores)

• Velocidade: valor real entre -3 e 3

• Ângulo: valor real entre -0.42 e 0.42

• Velocidade angular: valor real entre -3 e 3

Uma tabela Q precisaria discretizar cada dimensão.

Com apenas 10 divisões por dimensão: 10⁴ = 10.000 estados

Com 100 divisões: 100⁴ = 100 MILHÕES de estados!

Isso é inviável.

✅ SOLUÇÃO DO DQN:

A rede neural aprende a GENERALIZAR!

Ela mapeia estados contínuos diretamente para valores Q.

Sem discretização, sem explosão combinatória.

✅ TAMANHO DA REDE USADA:

• 4 entradas (estado contínuo)

• 2 camadas ocultas com 24 neurônios cada

• 2 saídas (Q para esquerda e direita)

Total de parâmetros: ~1.200 (muito menor que uma tabela!)

""")

# ============================================

# EXPLICAÇÃO MATEMÁTICA

# ============================================

print("\n" + "=" * 70)

print("FUNDAMENTOS DO DEEP Q-NETWORK (DQN)")

print("=" * 70)

print("""

✅ O PROBLEMA QUE O DQN RESOLVE:

Em espaços de estados contínuos, tabelas Q são inviáveis.

O número de estados cresce exponencialmente com dimensões.

✅ APROXIMAÇÃO DE FUNÇÕES:

Usamos uma rede neural Q(s,a; θ) para aproximar Q*(s,a).

θ são os pesos da rede (milhares, não milhões de parâmetros).

✅ FUNÇÃO DE PERDA DO DQN:

[latex] L(θ) = \\mathbb{E}_{(s,a,r,s') \\sim U(D)} [(r + \\gamma \\max_{a'} Q(s',a';θ^-) - Q(s,a;θ))^2] [/latex]

Onde:

- D é o buffer de replay (experience replay)

- θ⁻ são parâmetros da rede alvo (target network)

- U(D) é amostragem uniforme do buffer

✅ COMPONENTES CRÍTICOS DO DQN:

1. REPLAY BUFFER:

Armazena últimas N transições (s, a, r, s').

Amostragem aleatória quebra correlações temporais.

2. TARGET NETWORK:

Rede separada com parâmetros congelados θ⁻.

Atualizada a cada C passos (hard) ou via soft update.

Estabiliza o treinamento evitando alvos móveis.

3. ε-GREEDY COM DECAIMENTO:

Alta exploração no início, explotação no final.

✅ HIPERPARÂMETROS TÍPICOS:

• γ = 0.95 a 0.99 (fator de desconto)

• α = 0.00025 (taxa aprendizado - Adam)

• ε inicial = 1.0, ε final = 0.01

• ε decay = 0.995 (multiplicativo)

• Buffer size = 1.000.000 (para Atari)

• Batch size = 32 a 64

• Target update = 10.000 passos (hard) ou τ=0.001 (soft)

""")

print("\n" + "=" * 70)

print("CONCLUSÃO")

print("=" * 70)

print(f"""

✅ DQN é um marco histórico no aprendizado por reforço.

✅ Ele combina Q-Learning, redes neurais, replay buffer e target network.

✅ O agente aprendeu a equilibrar o CartPole em {episodios} episódios.

✅ A média final de recompensa foi {media_teste:.1f} (máximo 500).

RESULTADOS:

• Recompensa máxima obtida: {max(recompensas_episodio):.0f}

• Recompensa média (últimos 50): {np.mean(recompensas_episodio[-50:]):.1f}

• Epsilon final: {agente.epsilon:.3f}

• Tamanho da memória: {len(agente.memoria)}

O DQN foi usado para jogar Atari, superando humanos em vários jogos!

""")

print("\n✅ PROGRAMA CONCLUÍDO COM SUCESSO!")

Indice

Características da arquitetura DQN

Hiperparâmetros e fórmulas matemáticas

Exemplo clássico: ambiente CartPole

Deixe um comentário Cancelar resposta