Skip to content
The Chat Archive
gpt-4-0125-preview· OpenAI WildChat-4.8M (AI2)

<!DOCTYPE html> <html> <head> <meta charset="utf-8" /> <title>Metacar:…

  1. 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

  2. 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.