rl - Pekiştirmeli Öğrenme

DQN, PPO, SAC ve RL algoritmaları

Algoritma

Gym

Uyumlu

Replay

Buffer

Multi-Env

Destek

Genel Bakış

rl modülü, pekiştirmeli öğrenme için popüler algoritmaları (DQN, PPO, SAC) ve gym-uyumlu ortamları sağlar.

DQN

Deep Q-Network

Value-based
Discrete actions
Experience replay

PPO

Proximal Policy Optimization

Policy gradient
Clipped surrogate
On-policy

SAC

Soft Actor-Critic

Off-policy
Continuous actions
Maximum entropy

A2C/A3C

Actor-Critic

Advantage estimation
Async training
Fast learning

DQN - Deep Q-Network

CartPole-v1 Training

kullan ai/rl;
kullan ai/nn;

// Q-Network tanımla
değişken q_network = Sequential::yeni([
    Linear::yeni(4, 128),   // State dimension
    ReLU::yeni(),
    Linear::yeni(128, 128),
    ReLU::yeni(),
    Linear::yeni(128, 2)    // Action dimension
]);

// DQN agent
değişken agent = DQN::yeni(
    q_network: q_network,
    learning_rate: 0.001,
    gamma: 0.99,
    epsilon_start: 1.0,
    epsilon_end: 0.01,
    epsilon_decay: 0.995,
    buffer_size: 10000,
    batch_size: 64
);

// Ortam
değişken env = gym::make("CartPole-v1")?;

// Training loop
her episode içinde aralık(500) için yap
    değişken state = env.reset()?;
    değişken total_reward = 0.0;
    
    çevrim yap
        // Action seç (epsilon-greedy)
        değişken action = agent.act(state);
        
        // Step
        değişken (next_state, reward, done, _) = env.step(action)?;
        
        // Deneyimi kaydet
        agent.remember(state, action, reward, next_state, done);
        
        // Replay ve öğren
        eğer agent.buffer.len() > batch_size ise yap
            agent.replay()?;
        son
        
        state = next_state;
        total_reward += reward;
        
        eğer done ise yap kır; son
    son
    
    yazdir("Episode {}: Reward = {:.2f}, Epsilon = {:.3f}", 
           episode, total_reward, agent.epsilon);
son

Double DQN

kullan ai/rl;

// Double DQN (overestimation önleme)
değişken agent = DoubleDQN::yeni(
    q_network: q_network,
    target_update_freq: 100,  // Her 100 step'te target network güncelle
    learning_rate: 0.001
);

// Target network periyodik güncelleme
eğer step % agent.target_update_freq == 0 ise yap
    agent.update_target_network();
son

PPO - Proximal Policy Optimization

Continuous Control

kullan ai/rl;
kullan ai/nn;

// Actor-Critic network
sınıf ActorCritic {
    değişken shared: Sequential;
    değişken actor: Linear;
    değişken critic: Linear;
    
    fonksiyon yeni(state_dim: tamsayı, action_dim: tamsayı) -> ActorCritic yap
        ActorCritic {
            shared: Sequential::yeni([
                Linear::yeni(state_dim, 256),
                ReLU::yeni(),
                Linear::yeni(256, 256),
                ReLU::yeni()
            ]),
            actor: Linear::yeni(256, action_dim),
            critic: Linear::yeni(256, 1)
        }
    son
    
    fonksiyon ileri(değişken kendi, state: Tensor) -> (Tensor, Tensor) yap
        değişken features = kendi.shared.ileri(state);
        değişken action_mean = kendi.actor.ileri(features);
        değişken value = kendi.critic.ileri(features);
        dön (action_mean, value);
    son
}

// PPO agent
değişken agent = PPO::yeni(
    policy: ActorCritic::yeni(state_dim: 24, action_dim: 4),
    learning_rate: 3e-4,
    gamma: 0.99,
    gae_lambda: 0.95,
    clip_epsilon: 0.2,
    epochs: 10,
    batch_size: 64
);

// Training
değişken env = gym::make("BipedalWalker-v3")?;

her iteration içinde aralık(1000) için yap
    // Rollout topla
    değişken trajectories = agent.collect_rollouts(env, steps: 2048)?;
    
    // PPO update
    değişken loss = agent.update(trajectories)?;
    
    // Değerlendirme
    değişken eval_reward = agent.evaluate(env, episodes: 5)?;
    yazdir("Iteration {}: Loss = {:.4f}, Reward = {:.2f}", 
           iteration, loss, eval_reward);
son

SAC - Soft Actor-Critic

Off-Policy Learning

kullan ai/rl;

// SAC agent (continuous actions için ideal)
değişken agent = SAC::yeni(
    state_dim: 11,
    action_dim: 3,
    hidden_dims: [256, 256],
    learning_rate: 3e-4,
    gamma: 0.99,
    tau: 0.005,          // Soft target update
    alpha: 0.2,          // Entropy coefficient
    auto_tune_alpha: doğru
);

değişken env = gym::make("Pendulum-v1")?;

her step içinde aralık(100000) için yap
    değişken state = env.reset()?;
    
    çevrim yap
        // Action sample (stochastic policy)
        değişken action = agent.select_action(state, evaluate: yanlış);
        
        değişken (next_state, reward, done, _) = env.step(action)?;
        
        // Replay buffer'a ekle
        agent.buffer.push(state, action, reward, next_state, done);
        
        // Update
        eğer step > 1000 ise yap  // Warm-up
            agent.update(batch_size: 256)?;
        son
        
        state = next_state;
        eğer done ise yap kır; son
    son
son

Replay Buffer

Experience Replay

kullan ai/rl;

// Standart replay buffer
değişken buffer = ReplayBuffer::yeni(
    capacity: 100000,
    state_dim: 4,
    action_dim: 2
);

// Deneyim ekle
buffer.push(state, action, reward, next_state, done);

// Batch sample
değişken batch = buffer.sample(batch_size: 64)?;

// Prioritized Experience Replay
değişken per_buffer = PrioritizedReplayBuffer::yeni(
    capacity: 100000,
    alpha: 0.6,      // Prioritization derecesi
    beta_start: 0.4,  // Importance sampling
    beta_frames: 100000
);

// TD error ile priority güncelle
per_buffer.update_priorities(indices, td_errors);

Custom Environment

Kendi Ortamınızı Oluşturun

kullan ai/rl;

trait Environment {
    fonksiyon reset(değişken kendi) -> Tensor;
    fonksiyon step(değişken kendi, action: Tensor) -> (Tensor, ondalık, mantıksal, Metadata);
    fonksiyon render(değişken kendi);
    fonksiyon close(değişken kendi);
}

sınıf GridWorld {
    değişken grid_size: tamsayı;
    değişken agent_pos: (tamsayı, tamsayı);
    değişken goal_pos: (tamsayı, tamsayı);
}

uygula Environment için GridWorld yap
    fonksiyon reset(değişken kendi) -> Tensor yap
        kendi.agent_pos = (0, 0);
        dön kendi.get_state();
    son
    
    fonksiyon step(değişken kendi, action: Tensor) -> (Tensor, ondalık, mantıksal, Metadata) yap
        // Action: 0=up, 1=right, 2=down, 3=left
        değişken (x, y) = kendi.agent_pos;
        
        match action.item() yap
            0 => y -= 1,  // Up
            1 => x += 1,  // Right
            2 => y += 1,  // Down
            3 => x -= 1,  // Left
            _ => {}
        son
        
        // Sınırları kontrol et
        x = x.clamp(0, kendi.grid_size - 1);
        y = y.clamp(0, kendi.grid_size - 1);
        kendi.agent_pos = (x, y);
        
        // Reward hesapla
        değişken reward = eğer kendi.agent_pos == kendi.goal_pos ise yap
            1.0
        son yoksa yap
            -0.01  // Small penalty for each step
        son;
        
        değişken done = kendi.agent_pos == kendi.goal_pos;
        
        dön (kendi.get_state(), reward, done, Metadata::yeni());
    son
son

Multi-Environment Training

Parallel Environments

kullan ai/rl;

// Vectorized environment (paralel)
değişken vec_env = VecEnv::yeni(
    env_name: "CartPole-v1",
    num_envs: 8,
    parallel: doğru
)?;

// Tüm env'ler aynı anda step
değişken states = vec_env.reset();
değişken actions = agent.act_batch(states);
değişken (next_states, rewards, dones, _) = vec_env.step(actions)?;

// Her env için ayrı işlem
her i içinde aralık(num_envs) için yap
    eğer dones[i] ise yap
        vec_env.reset_env(i);
    son
son

Policy Evaluation

Agent Değerlendirme

kullan ai/rl;

fonksiyon evaluate_policy(
    agent: Agent,
    env: Environment,
    num_episodes: tamsayı
) -> ondalık yap
    değişken total_rewards = [];
    
    her episode içinde aralık(num_episodes) için yap
        değişken state = env.reset();
        değişken episode_reward = 0.0;
        
        çevrim yap
            // Deterministic action (no exploration)
            değişken action = agent.select_action(state, evaluate: doğru);
            değişken (next_state, reward, done, _) = env.step(action)?;
            
            episode_reward += reward;
            state = next_state;
            
            eğer done ise yap kır; son
        son
        
        total_rewards.push(episode_reward);
    son
    
    dön total_rewards.iter().sum::() / num_episodes as ondalık;
son

// Kullanım
değişken mean_reward = evaluate_policy(agent, env, num_episodes: 10);
yazdir("Ortalama reward: {:.2f}", mean_reward);

Hyperparameter Tuning

Grid Search

kullan ai/rl;

değişken learning_rates = [1e-4, 3e-4, 1e-3];
değişken gammas = [0.95, 0.99, 0.999];

değişken best_reward = -∞;
değişken best_params = yok;

her lr içinde learning_rates için yap
    her gamma içinde gammas için yap
        değişken agent = PPO::yeni(
            policy: policy,
            learning_rate: lr,
            gamma: gamma
        );
        
        değişken reward = train_and_evaluate(agent, env, iterations: 100)?;
        
        eğer reward > best_reward ise yap
            best_reward = reward;
            best_params = bazı((lr, gamma));
        son
        
        yazdir("LR={}, Gamma={}: Reward={:.2f}", lr, gamma, reward);
    son
son

Algoritma Karşılaştırması

Algoritma	Tip	Action Space	Sample Efficiency	Kullanım
DQN	Value-based	Discrete	Orta	Atari oyunları
Double DQN	Value-based	Discrete	Orta	Overestimation önleme
PPO	Policy gradient	Both	Düşük	Genel amaçlı
A2C	Actor-Critic	Both	Düşük	Hızlı prototipleme
SAC	Actor-Critic	Continuous	Yüksek	Robotik kontrol
TD3	Actor-Critic	Continuous	Yüksek	Continuous control

API Referansı

DQN Sınıfı

yeni(q_network: Network, ...) -> DQN
act(kendi, state: Tensor) -> Tensor - Action seç
remember(kendi, ...) - Deneyim kaydet
replay(kendi) -> Sonuç - Batch update

PPO Sınıfı

yeni(policy: ActorCritic, ...) -> PPO
collect_rollouts(kendi, env: Environment, ...) -> Trajectories
update(kendi, trajectories: Trajectories) -> ondalık
evaluate(kendi, env: Environment, ...) -> ondalık

ReplayBuffer Sınıfı

yeni(capacity: tamsayı, ...) -> ReplayBuffer
push(kendi, state, action, reward, next_state, done)
sample(kendi, batch_size: tamsayı) -> Batch
len(kendi) -> tamsayı

Keyboard shortcuts

BERK Programlama Dili