<!DOCTYPE html> <html> <head> <meta charset="utf-8" /> <title>Metacar:…
- User
<div id="env"></div> <script src="https://cdn.jsdelivr.net/combine/npm/metacar@0.1.1,npm/metacar@0.1.1"></script> <script> // Select a level const level = metacar.level.level0; // Create the environement const env = new metacar.env("env", level); // Set the agent motion env.setAgentMotion(metacar.motion.BasicMotion, {rotationStep: 0.1}); // Create the model // Input const input = tf.input({batchShape: [null, 26]}); // Hidden layer const layer = tf.layers.dense({useBias: true, units: 32, activation: 'relu'}).apply(input); // Output layer const output = tf.layers.dense({useBias: true, units: 3, activation: 'linear'}).apply(layer); // Create the model const model = tf.model({inputs: input, outputs: output}); // Optimize let model_optimizer = tf.train.adam(0.01); // Loss of the model function model_loss(tf_states, tf_actions, Qtargets){ return tf.tidy(() => { // valeur return model.predict(tf_states).sub(Qtargets).square().mul(tf_actions).mean(); }); } // Pick an action eps-greedy function pickAction(st, eps){ let st_tensor = tf.tensor([st]); let act; if (Math.random() < eps){ // Pick a random action act = Math.floor(Math.random()*3); } else { let result = model.predict(st_tensor); let argmax = result.argMax(1); act = argmax.buffer().values[0]; argmax.dispose(); result.dispose(); } st_tensor.dispose(); return act; } // Return the mean of an array function mean(array){ if (array.length == 0) return null; var sum = array.reduce(function(a, b) { return a + b; }); var avg = sum / array.length; return avg; } // Train the model function train_model(states, actions, rewards, next_states){ var size = next_states.length; // Transform each array into a tensor let tf_states = tf.tensor2d(states, shape=[states.length, 26]); let tf_rewards = tf.tensor2d(rewards, shape=[rewards.length, 1]); let tf_next_states = tf.tensor2d(next_states, shape=[next_states.length, 26]); let tf_actions = tf.tensor2d(actions, shape=[actions.length, 3]); // Get the list of loss to compute the mean later in this function let losses = [] // Get the QTargets const Qtargets = tf.tidy(() => { let Q_stp1 = model.predict(tf_next_states); let Qtargets = tf.tensor2d(Q_stp1.max(1).expandDims(1).mul(tf.scalar(0.99)).add(tf_rewards).buffer().values, shape=[size, 1]); return Qtargets; }); // Generate batch of training and train the model let batch_size = 32; for (var b = 0; b < size; b+=32) { // Select the batch let to = (b + batch_size < size) ? batch_size : (size - b); const tf_states_b = tf_states.slice(b, to); const tf_actions_b = tf_actions.slice(b, to); const Qtargets_b = Qtargets.slice(b, to); // Minimize the error model_optimizer.minimize(() => { const loss = model_loss(tf_states_b, tf_actions_b, Qtargets_b); losses.push(loss.buffer().values[0]); return loss; }); // Dispose the tensors from the memory tf_states_b.dispose(); tf_actions_b.dispose(); Qtargets_b.dispose(); } console.log("Mean loss", mean(losses)); // Dispose the tensors from the memory Qtargets.dispose(); tf_states.dispose(); tf_rewards.dispose(); tf_next_states.dispose(); tf_actions.dispose(); } env.load().then(() => { env.addEvent("play", () => { // Move forward let st = env.getState().linear; let act = pickAction(st, 0.0); let reward = env.step(act); console.log(reward); // Log the reward }); env.addEvent("stop", () => { return; }); env.addEvent("train", async () => { let eps = 1.0; // Used to store the experiences let states = []; let rewards = []; let reward_mean = []; let next_states = []; let actions = []; // Get the current state of the lidar let st = env.getState().linear; let st2; for (let epi=0; epi < 150; epi++){ let reward = 0; let step = 0; while (step < 400){ // pick an action let act = pickAction(st, eps); reward = env.step(act); st2 = env.getState().linear; let mask = [0, 0, 0]; mask[act] = 1; // Randomly insert the new transition tuple let index = Math.floor(Math.random() * states.length); states.splice(index, 0, st); rewards.splice(index, 0, [reward]); reward_mean.splice(index, 0, reward) next_states.splice(index, 0, st2); actions.splice(index, 0, mask); // Be sure to keep the size of the dataset under 10000 transitions if (states.length > 10000){ states = states.slice(1, states.length); rewards = rewards.slice(1, rewards.length); reward_mean = reward_mean.slice(1, reward_mean.length); next_states = next_states.slice(1, next_states.length); actions = actions.slice(1, actions.length); } st = st2; step += 1; } // Decrease epsilon eps = Math.max(0.1, eps*0.99); // Train model every 5 episodes if (epi % 5 == 0){ console.log("---------------"); console.log("rewards mean", mean(reward_mean)); console.log("episode", epi); await train_model(states, actions, rewards, next_states); await tf.nextFrame(); } // Shuffle the env env.shuffle(); } env.render(true); }); }); </script>Transform ce programe en python
- Assistant
Transformer votre exemple de code JavaScript en Python impliquerait de le réarranger pour être utilisé avec une bibliothèque Python qui supporte l'apprentissage profond comme TensorFlow pour Python. De plus, pour un environnement interactif comme celui fourni par Metacar dans votre code JavaScript, une approche pourrait être d'utiliser une bibliothèque de simulation ou un environnement de Reinforcement Learning (RL) comme Gym de OpenAI pour gérer l'environnement.
Notez que le code ci-dessous est une conversion conceptuelle et n'inclut pas l'environnement Metacar, qui n'a pas de correspondance directe en Python à ma connaissance. Vous devriez créer ou trouver un environnement similaire pour votre cas d'utilisation spécifique.
import numpy as np import tensorflow as tf from tensorflow.keras import layers, models, optimizers # Supposons que vous avez trouvé ou créé un environnement Python qui ressemble à Metacar import metacar_python_env as metacar # Configuration de l'environnement env = metacar.create_environment(level=0) # Création du modèle input_layer = tf.keras.Input(shape=(26,)) hidden_layer = layers.Dense(32, activation='relu')(input_layer) output_layer = layers.Dense(3, activation='linear')(hidden_layer) model = models.Model(inputs=input_layer, outputs=output_layer) # Compilation du modèle optimizer = optimizers.Adam(0.01) model.compile(optimizer=optimizer, loss='mse') def pick_action(model, state, epsilon): if np.random.rand() < epsilon: return np.random.randint(3) # Choisissez une action au hasard parmi 3 else: Q_values = model.predict(state[None]) return np.argmax(Q_values[0]) # Choisissez l'action avec la valeur Q maximale def mean(array): return np.mean(array) def train_model(model, states, actions, rewards, next_states): with tf.GradientTape() as tape: # Prédiction des Q-values pour les états actuels q_values = model(states) # Calcul des Q-values max pour les prochains états next_q_values = model.predict(next_states) max_next_q_values = np.max(next_q_values, axis=1) target_q_values = (rewards + 0.99 * max_next_q_values).reshape(-1, 1) mask = tf.one_hot(actions, 3) with tf.GradientTape() as tape: all_q_values = model(states) q_values = tf.reduce_sum(all_q_values * mask, axis=1, keepdims=True) loss = tf.reduce_mean(tf.square(target_q_values - q_values)) grads = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(grads, model.trainable_variables)) print("Mean loss:", np.mean(loss.numpy())) # Entraînement eps = 1.0 for epi in range(150): state = env.reset() rewards_sum = 0 done = False while not done: action = pick_action(model, state, eps) next_state, reward, done, _ = env.step(action) # Mettre à jour l'état state = next_state rewards_sum += reward # Mise à jour epsilon après chaque épisode eps = max(0.1, eps * 0.99) # Optionnel : Vous pouvez accumuler des informations comme les états, les actions, etc., pour les utiliser dans l'entraînement # Note: Cette partie du code ne traite pas de l'entraînement par lots ou de la mise à jour des poids du modèle basée sur la réexpérience, comme dans votre exemple JS. Vous devriez stocker les transitions (état, action, récompense, état suivant) et périodiquement entraîner votre modèle en lots à partir de cette "mémoire de réexpérience" pour une implémentation complète de DQN.Ce script est une ébauche de haut niveau. L'implémentation précise, notamment l'intégration avec l'environnement spécifique et les ajustements nécessaires à la logique d'entraînement (tel que le fonctionnement du gradient et la logique de récompenses), nécessitera des modifications en fonction des détails de votre environnement Metacar et de vos objectifs d'entraînement.