Using GAMA for Predictive and Adaptive Simulations

[GamaDevp]

I am reaching out for guidance on a simulation project I am developing using GAMA. The goal of my project is to simulate a snowstorm scenario where snowplows dynamically manage snow accumulation on roads. This model is intended as a step toward building a larger framework that incorporates predictive and adaptive decision-making capabilities, possibly using reinforcement learning, for resource allocation during natural disasters.

The project involves modeling a snowstorm’s impact on a road network, with the following objectives:

• Roads experience varying levels of snow accumulation over time, influenced by stochastic rates and other parameters.

• Snow levels on each road segment are updated dynamically and stored in a snow_field variable.

• Snowplows should monitor snow levels on roads and prioritize clearing based on the severity of snow accumulation and road importance.

• Each snowplow should act autonomously and adjust its actions dynamically based on real-time snow data.

Future iterations of the model aim to include predictive mechanisms, enabling snowplows to forecast snow accumulation trends on roads and plan their actions proactively.
This might involve reinforcement learning algorithms for decision-making, where snowplows learn optimal clearing strategies based on simulation feedback.

Immediate Challenges:
At this stage, I am focusing on implementing the first step of dynamic snowplow management based on snow accumulation.

However, I am encountering the following issues:
-> I am unsure how to integrate road-specific snow levels from the snow_field into the snowplows’ decision-making process effectively.
For example, how can I prioritize roads dynamically based on their snow accumulation levels in real time?

-> Does GAMA support predictive modeling or reinforcement learning algorithms that could enable agents (e.g., snowplows) to forecast conditions and adapt their actions over time?
If not directly supported, are there best practices or integrations available to achieve this functionality within GAMA?

-> How can I design the simulation so multiple snowplows coordinate their efforts to avoid redundancy and optimize clearing efficiency across the road network?

I would appreciate any advice or references you could provide on:

1. Designing agent reflexes or behaviors to dynamically react to road-specific snow conditions.
2. Integrating predictive capabilities or external learning algorithms into GAMA models.
3. Approaches for efficient coordination between multiple agents in a shared environment.

Here is my code so far:

model SnowStorm

global {

    file building_shapefile <- file("../includes/buildings.shp");

    file road_shapefile <- file("../includes/roads.shp");
    
    
     
    geometry shape <- envelope(building_shapefile) + envelope(road_shapefile);
    
    float step <- 60 #s;
    field<float> snow_field <- field(300, 300, 0.0); 
    
    graph road_network;
    
    map<road, float> road_weights;   
    
    float high_snow_accumulation_rate <- 5.0;
    
    float base_snow_accumulation_rate <- 2.0;
    float base_snow_clearing_rate <- 2.0;
    
    float snow_threshold <- 1000.0; 
    float total_snow <- 0.0;
    bool allow_snow_accumulation <- true;
    int current_cycle <- 0;
    int max_cycles <- 50;
    int clear_cycles <- 110;
    bool allow_snowplow_action <- false;
    bool allow_snow_clear <- true;
	
	
	float previous_total_snow <- 0.0;       // Total snow in the field at the previous cycle
	float total_snow_dissipated <- 0.0;    // Total snow removed globally
 	list<float> total_snow_removed_over_time <- [];
	
	float total_snow_cleared_global <- 0.0; // Tracks total snow cleared globally
    list<float> snow_cleared_over_time <- []; // Tracks total snow cleared at each cycle
    
 
    
    
    init {
	
    list<point> rescue_stations <- [ {100, 100}, {500, 300}, {900, 700} ];
    create rescue_station from: rescue_stations;
    create snowplow number: 25 {}


//Tracking of snow in the field
 	float total_time_to_clear <- 0.0; // Sum of time to clear snow by all snowplows
    int total_snow_cleared <- 0;     // Total amount of snow cleared
    int total_clear_events <- 0;    // Number of snow-clearing events (to calculate average)
    list<float> snow_clear_times <- []; // Tracks individual clearing times for analysis

        create building from: building_shapefile;
        create road from: road_shapefile;
        int num_roads <- length(road);
        write "Number of roads created: " + num_roads;
        road_network <- as_edge_graph(road);
        road_weights <- road as_map (each::each.shape.perimeter);
        
      
        
        //create snow number:10;
		
	}
	
	reflex track_cycles {
		current_cycle <- current_cycle + 1;
		if (current_cycle >= max_cycles){
			allow_snow_accumulation <- false;
			allow_snowplow_action <- true;
			
		}
	}

	reflex snow_accumulation when: allow_snow_accumulation {
        ask road {
            float random_rate <- base_snow_accumulation_rate * (1.0 + rnd(1.5)); 
            
            snow_field[self.location] <- snow_field[self.location] + random_rate;
        }
        
        diffuse var: snow_field on: snow_field proportion: 0.9;
        
    }
   
    reflex update_snow_accumulation {
    	ask road {
    		snow_accumulation <- snow_field[self.location];
    	}
    }
    
    reflex update_total_snow {
    	total_snow <- sum_of(road, each.snow_accumulation);

    }

	reflex update_road_speed {
		road_network <- road_network with_weights road_weights;
	}
}

species snowplow skills: [moving] {
    float speed <- 0.1;           
    point target <- nil;          
    int clearing_start_time <- 0;
    bool allow_snowplow_action <- true;
    list<float> snow_clear_times <- []; 
    

    reflex find_target when: target = nil and allow_snowplow_action {
        building random_building <- one_of(building);
        if (random_building != nil) {
            target <- random_building.location; 
            
         } 
    }

    // Reflex to move fluidly toward the target while clearing snow
    reflex move_and_clear when: target != nil {

        path path_followed <- goto(target: target, on: road_network, recompute_path: false, return_path: true);
		

 
        if (path_followed != nil and path_followed.shape != nil) {
        	float current_snow <- snow_field[path_followed.shape.location];
        	
			if (current_snow > 0) {
            // Track the amount of snow removed globally
            total_snow_cleared_global <- total_snow_cleared_global + current_snow;	
            
            //Clear Snow		        	
            snow_field[path_followed.shape.location] <- -5.0; 
        }
}

        if (location distance_to(target) < 1.0) {
          target <- nil; 
        }
    }

    // Default appearance
    aspect default {
        draw rectangle(6, 12) rotated_by (heading + 90) color: #blue depth: 3;
    }
}


species rescue_station {
    point location;  // Location of the station

    aspect default {
        draw circle(10) color: #red depth: 2;  // Draw a red circle at the station
    }
}

species snow {
    float accumulation <- 0.0;

    aspect default {
        draw shape color: #white depth: 1 size: accumulation * 0.1;
    }
}

species building {
    aspect default {
        draw shape color: darker(#darkgray).darker depth: rnd(10) + 2;
    }
}


species road {
	int road_id;
	float snow_accumulation <- 0.0;
	reflex log_snow_levels {
    if (snow_accumulation > 0) {
        //write "Road at " + location + " has snow: " + snow_accumulation;
    }
}
	aspect default {
        draw shape color: #gray;
    }
}


experiment storm type: gui autorun: true {
    float minimum_cycle_duration <- 0.1;
    list<rgb> pal <- palette([#lightblue, #navy]);
    float total_time_to_clear <- 0.0; // Sum of time to clear snow by all snowplows
    int total_snow_cleared <- 0;     // Total amount of snow cleared
    int total_clear_events <- 0;    // Number of snow-clearing events (to calculate average)
    list<float> snow_clear_times <- []; // Tracks individual clearing times for analysis

    output synchronized: true {
    	
        // 3D Display for the simulation
        display carte type: 3d axes: false background: rgb(245, 245, 245) fullscreen: false toolbar: false {
            light #ambient intensity: 200;
            camera 'default' location: {1254.041, 2938.6921, 1792.4286} target: {1258.8966, 1547.6862, 0.0};
            species road refresh: true;
            species building refresh: false;
            species snowplow;
            mesh snow_field scale: 30 triangulation: true transparency: 0.5 smooth: 3 above: 0.8 color: pal;
        }


}

 }

[lesquoyb]

Hello,

For your first question I'm not really sure what you mean, I think you could simply sort the roads by their current levels or apply whatever decision algorithm you think is relevant to your model ?

For the second question, the most versatile way to do it is probably to use the network capabilities of agents (see this), using "localhost" address in case both your simulation and external algorithm are on the same computer. This way you could have agents in the simulation sending data to your external algorithm, and then the external algorithm sending back decisions or learning from it.
This solution has been experimented multiple times already and is proven to be reliable, though the drawbacks are that it may a bit slow (depending on what you are doing) and requires you to write a bit of code to handle communications both in gama and on the external algorithm side.
Now if you just want to import a decision model that has already been learned externally, you can do so by saving it in the PMML format and importing it directly in GAMA to take decisions with it in your simulation. This has the advantage of being extremely efficient, but is limited to already trained models that can be converted into PMML format (so mostly trained in python and R, see online for supported models and libraries) and cannot be used to train a model. It also requires you to install the PMML plugin into your gama installation (see this page) and to run the latest alpha version of gama that you can find here.

Hope it helps,

Baptiste