ChatGPT first try at Actor-critic for HVAC management

[tochinet]

#include <Arduino.h>
#include <vector>
#include <cmath>
#include <random>

#define NUM_STATES 24  // Exemple : combinaisons de température intérieure/extérieure
#define NUM_ACTIONS 2  // Chauffage ON / OFF
#define LEARNING_RATE 0.1
#define DISCOUNT_FACTOR 0.99
#define EXPLORATION_RATE 0.1  // Probabilité d'exploration

// Structure pour stocker les valeurs d'état-action
struct ActorCritic {
    float state_values[NUM_STATES]; // Critic : Valeur de l'état
    float policy[NUM_STATES][NUM_ACTIONS]; // Actor : Probabilité d'action
    float eligibility[NUM_STATES]; // Pour mise à jour du Critic (trace d'éligibilité)
    
    ActorCritic() {
        for (int i = 0; i < NUM_STATES; i++) {
            state_values[i] = 0.0f;
            eligibility[i] = 0.0f;
            for (int j = 0; j < NUM_ACTIONS; j++) {
                policy[i][j] = 0.5f; // Initialisation uniforme
            }
        }
    }

    int choose_action(int state) {
        // Exploration aléatoire
        if ((rand() / (float)RAND_MAX) < EXPLORATION_RATE) {
            return rand() % NUM_ACTIONS;
        }
        // Exploitation : choisir selon la politique
        return (policy[state][0] > policy[state][1]) ? 0 : 1;
    }

    void update(int state, int action, float reward, int next_state) {
        float td_error = reward + DISCOUNT_FACTOR * state_values[next_state] - state_values[state];
        eligibility[state] += 1.0;

        // Mise à jour du Critic
        for (int i = 0; i < NUM_STATES; i++) {
            state_values[i] += LEARNING_RATE * td_error * eligibility[i];
            eligibility[i] *= DISCOUNT_FACTOR; // Atténuation de la trace
        }

        // Mise à jour de l'Actor
        policy[state][action] += LEARNING_RATE * td_error;
    }
};

ActorCritic ac;

void setup() {
    Serial.begin(115200);
    randomSeed(analogRead(0));
}

void loop() {
    int state = random(NUM_STATES);
    int action = ac.choose_action(state);
    
    // Simulation de récompense (ex: confort thermique, économie d'énergie)
    float reward = (action == 1) ? 1.0f : -0.5f; 
    int next_state = (state + 1) % NUM_STATES;

    ac.update(state, action, reward, next_state);
    
    delay(1000);
}

[tochinet]

Et la version avec Posit

[tochinet]

#include <Arduino.h>
#include <vector>
#include <cmath>
#include <random>
#include "posit.h"  // Supposons une implémentation de Posit<8,2> et Posit<16,2>

#define NUM_STATES 24  // Exemple : combinaisons de température intérieure/extérieure
#define NUM_ACTIONS 2  // Chauffage ON / OFF
#define LEARNING_RATE posit<16,2>(0.1)
#define DISCOUNT_FACTOR posit<16,2>(0.99)
#define EXPLORATION_RATE 0.1  // Probabilité d'exploration

// Structure pour stocker les valeurs d'état-action
struct ActorCritic {
    posit<8,2> state_values[NUM_STATES]; // Critic : Valeur de l'état en Posit<8,2>
    posit<8,2> policy[NUM_STATES][NUM_ACTIONS]; // Actor : Probabilité d'action en Posit<8,2>
    posit<16,2> eligibility[NUM_STATES]; // Trace d'éligibilité en Posit<16,2>
    
    ActorCritic() {
        for (int i = 0; i < NUM_STATES; i++) {
            state_values[i] = posit<8,2>(0.0);
            eligibility[i] = posit<16,2>(0.0);
            for (int j = 0; j < NUM_ACTIONS; j++) {
                policy[i][j] = posit<8,2>(0.5); // Initialisation uniforme
            }
        }
    }

    int choose_action(int state) {
        // Exploration aléatoire
        if ((rand() / (float)RAND_MAX) < EXPLORATION_RATE) {
            return rand() % NUM_ACTIONS;
        }
        // Exploitation : choisir selon la politique
        return (policy[state][0] > policy[state][1]) ? 0 : 1;
    }

    void update(int state, int action, posit<16,2> reward, int next_state) {
        posit<16,2> td_error = reward + DISCOUNT_FACTOR * posit<16,2>(state_values[next_state]) - posit<16,2>(state_values[state]);
        eligibility[state] += posit<16,2>(1.0);

        // Mise à jour du Critic
        for (int i = 0; i < NUM_STATES; i++) {
            state_values[i] = posit<8,2>(posit<16,2>(state_values[i]) + LEARNING_RATE * td_error * eligibility[i]);
            eligibility[i] *= DISCOUNT_FACTOR; // Atténuation de la trace
        }

        // Mise à jour de l'Actor
        policy[state][action] = posit<8,2>(posit<16,2>(policy[state][action]) + LEARNING_RATE * td_error);
    }
};

ActorCritic ac;

void setup() {
    Serial.begin(115200);
    randomSeed(analogRead(0));
}

void loop() {
    int state = random(NUM_STATES);
    int action = ac.choose_action(state);
    
    // Simulation de récompense (ex: confort thermique, économie d'énergie)
    posit<16,2> reward = (action == 1) ? posit<16,2>(1.0) : posit<16,2>(-0.5); 
    int next_state = (state + 1) % NUM_STATES;

    ac.update(state, action, reward, next_state);
    
    delay(1000);
}