Skip to content

BDIAgents_step5

Jump to bottom
Baptiste Lesquoy edited this page Apr 12, 2022 · 12 revisions

5. Norms, obligation, and enforcement

This last step consists of adding social norms, obligations, and enforcement into the agents' behavior.

Formulation

  • Definition of the policeman species
  • Definition of the enforcement done by policeman species
  • Definition of the law agents have to follow
  • Definition of a gold miner norm to fulfill its obligation and its social norms
  • Definition of the enforcement done by gold miners

Norms, obligations, and enforcement

The BDI architecture of GAMA allows defining explicit social norms, laws that lead to obligations and an enforcement process to sanction or reward the other agent depending on their behavior toward norms. A social norm is a set of actions executed under certain conditions which are known by the people as the right things to do in that condition. As it is, it can be assimilated into a plan. However, a norm can be violated which mean an agent chose to disobey and do not execute it while it should. To do this, each agent has an obedient value, between 0 and 1 and computed from its personality and each norm has a threshold. If the obedient value of the agent is above the threshold, the norm is executed.

An obligation is a mental state that can be assimilated with a desire. It is created by a law that indicates under which conditions the agent has to follow a particular obligation. Once again, the law can have a threshold value to be activated or not depending on the obedient value of the agent. If an agent has an obligation, it will give up its current intention and current plan to get this obligation as its intention. Then, it will choose a specific norm to answer this obligation, once again with a threshold on the obedient value.

Finally, an enforcement mechanism can be defined during the perception process. Norms, laws, and obligation can be enforced. If a violation is detected, a sanction can be executed. If the norm/law/obligation is fulfilled, a reward can be executed.

Model Definition

law

We add a law to the gold miner species that will create the obligation to get gold if a gold nugget is perceived. This law replaces a rule and expresses the fact that miners are working or not, depending on their obedience value.

species miner skills: [moving] control:simple_bdi {
    ...
    law working belief: mine_location new_obligation: has_gold 
       when:not has_obligation(has_gold) and not has_belief(has_gold) strength: 2.0 threshold: threshold_aw;
	
        ...
}

norms

The miners will have two norms. A first one to answer the obligation to collect gold. This norm replaces the previous plan created for this purpose. However, a new plan is declared to get 3 pieces of gold at each time. This plan will be considered illegal by the policeman species.

species miner skills: [moving] control: simple_bdi {
    ...
    norm doing_job obligation: has_gold finished_when: has_belief(has_gold) threshold: threshold_obligation {
	if (target = nil) {
	    do add_subintention(has_gold,choose_gold_mine, true);
	    do current_intention_on_hold();
	} else {
	    do goto target: target ;
	    if (target = location)  {
		gold_mine current_mine<- gold_mine first_with (target = each.location);
		if current_mine.quantity > 0 {
		    gold_transported <- gold_transported+1;
		    do add_belief(has_gold);
		    ask current_mine {quantity <- quantity - 1;}	
		} else {
		    do add_belief(new_predicate(empty_mine_location, ["location_value"::target]));
		    do remove_belief(new_predicate(mine_at_location, ["location_value"::target]));
		}
		target <- nil;
	    }
	}	
    }
}

The second norm is a social norm to communicate the list of known mines to one's friends. It replaces the previous plan that did this action, while a new plan is added to give a wrong list of mines to one's friend.

species miner skills: [moving] control: simple_bdi {
    ...
    norm share_information intention: share_information threshold: threshold_norm instantaneous: true {
	list<miner> my_friends <- list<miner>((social_link_base where (each.liking > 0)) collect each.agent);
	loop known_gold_mine over: get_beliefs_with_name(mine_at_location) {
	    ask my_friends {
		do add_belief(known_gold_mine);
	    }
	}
	loop known_empty_gold_mine over: get_beliefs_with_name(empty_mine_location) {
	    ask my_friends {
		do add_belief(known_empty_gold_mine);
	    }
	}
		
	do remove_intention(share_information, true); 
    }
}

Enforcement of the social norm

Finally, for the gold-miner agent, an enforcement is defined about the social norm to communicate the location of mines to other agents. A sanction and a reward are declared to change the liking value with the agent controlled, depending on if the norm is violated or fulfilled.

species miner skills: [moving] control:simple_bdi {
    ...
    perceive target: miner in: view_dist {
	myself.agent_perceived <- self;
	enforcement norm:"share_information" sanction:"sanction_to_norm" reward:"reward_to_norm";
    }
		
    sanction sanction_to_norm{
	do change_liking(agent_perceived,-0.1);
    }	
	
    sanction reward_to_norm{
	do change_liking(agent_perceived,0.1);
    }
}

Definition of policeman species

Finally, we define a policeman species that will wander through the map and enforce the miners about the law and the obligation. The sanctions will be a fine collected by policemen.

species policeman skills: [moving] control:simple_bdi {
    predicate patroling <- new_predicate("patrolling");
    float view_dist <- 1000.0;
    miner agent_perceived <- nil;
	
    init {
	do add_desire(patroling);
    }
	
    perceive target:miner in: view_dist {
	myself.agent_perceived <- self;
	enforcement law: "working" sanction: "sanction_to_law";
	enforcement obligation: has_gold sanction: "sanction_to_obligation" reward: "reward_to_obligation";
    }
	
    sanction sanction_to_law {
	ask agent_perceived{
	    threshold_law <- 0.0;
	    gold_sold <- gold_sold-5;
	}
	fine <- fine +5;
    }
	
    sanction sanction_to_obligation {
	ask agent_perceived{
	    gold_sold <- gold_sold-3;
	    do remove_intention(sell_gold,true);
	    thresholdObligation <- self.threshold_obligation - 0.1;
	}
	fine <- fine + 3;
    }
	
    sanction reward_to_obligation{
	ask agent_perceived{
	    gold_sold <- gold_sold+2;
	}
	fine <- fine - 2;
    }
	
    plan patrol intention: patroling{
	do wander;
    }
	
    aspect base{
	draw circle(view_dist) color: #blue depth:0.0;
    }
}

Modification of the chart

We add to the output chart displayed the data coming from the policeman.

display chart {
	    chart "Money" type: series {
		datalist legend: miner accumulate each.name value: miner accumulate each.gold_sold color: miner accumulate each.my_color;
                data "policeman" value: fine color: #red;
		}
	}

Complete Model

/***
* Name: BDItutorial5
* Author: Mathieu Bourgais
* Description: Addition of norms, obligation, and enforcement
* Tags: norm, obligation, enforcement
***/

model BDItutorial5

global {
	int nb_mines <- 10; 
	int nb_miners <- 5;
	int nb_police <- 1;
	int fine <- 0;
	market the_market;
	
	string mine_at_location <- "mine_at_location";
	string empty_mine_location <- "empty_mine_location";
	
	float step <- 10#mn;
	
	//possible predicates concerning miners
	predicate mine_location <- new_predicate(mine_at_location) ;
	predicate choose_gold_mine <- new_predicate("choose a gold mine");
	predicate has_gold <- new_predicate("extract gold");
	predicate find_gold <- new_predicate("find gold") ;
	predicate sell_gold <- new_predicate("sell gold") ;
	predicate share_information <- new_predicate("share information") ;
	
	
	emotion joy <- new_emotion("joy");
	
	float inequality <- 0.0 update:standard_deviation(miner collect each.gold_sold);
	
	geometry shape <- square(20 #km);
	init
	{
		create market {
			the_market <- self;	
		}
		create gold_mine number:nb_mines;
		create miner number:nb_miners;
		create policeman number:nb_police;
	}
	
	reflex display_social_links{
		loop tempMiner over: miner{
				loop tempDestination over: tempMiner.social_link_base{
					if (tempDestination !=nil){
						bool exists<-false;
						loop tempLink over: socialLinkRepresentation{
							if((tempLink.origin=tempMiner) and (tempLink.destination=tempDestination.agent)){
								exists<-true;
							}
						}
						if(not exists){
							create socialLinkRepresentation number: 1{
								origin <- tempMiner;
								destination <- tempDestination.agent;
								if(get_liking(tempDestination)>0){
									my_color <- #green;
								} else {
									my_color <- #red;
								}
							}
						}
					}
				}
			}
	}
	
	reflex end_simulation when: sum(gold_mine collect each.quantity) = 0 and empty(miner where each.has_belief(has_gold)){
		do pause;
		ask miner {
			write name + " : " +gold_sold;
		}
		write "**********************";
		write "fine : " + fine;
	}
}

species gold_mine {
    int quantity <- rnd(1,20);
    aspect default {
        draw triangle(200 + quantity * 50) color: (quantity > 0) ? #yellow : #gray border: #black;    
    }
}

species market {
	int golds;
	aspect default {
	  draw square(1000) color: #black ;
	}
}

species policeman skills: [moving] control:simple_bdi {
	predicate patroling <- new_predicate("patrolling");
	float view_dist <- 1000.0;
	miner agent_perceived <- nil;
	
	init {
		do add_desire(patroling);
	}
	
	perceive target: miner in: view_dist {
		myself.agent_perceived <-self;
		enforcement law:"working" sanction:"sanction_to_law";
		enforcement obligation:has_gold /*when:has_belief(has_gold)*/ sanction: "sanction_to_obligation" reward:"reward_to_obligation";
	}
	
	sanction sanction_to_law{
		ask agent_perceived{
			threshold_law <- 0.0;
			gold_sold <- gold_sold-5;
		}
		fine <- fine +5;
	}
	
	sanction sanction_to_obligation {
		ask agent_perceived{
			gold_sold <- gold_sold-3;
			do remove_intention(sell_gold,true);
			threshold_obligation <- self.threshold_obligation - 0.1;
		}
		fine <- fine + 3;
	}
	
	sanction reward_to_obligation{
		ask agent_perceived{
			gold_sold <- gold_sold+2;
		}
		fine <- fine -2;
	}
	
	plan patrol intention: patroling {
		do wander;
	}
	
	aspect base {
		draw circle(view_dist) color: #blue depth: 0.0;
	}
}

species miner skills: [moving] control:simple_bdi {
	
	float view_dist<-1000.0;
	float speed <- 2#km/#h;
	rgb my_color<-rnd_color(255);
	point target;
	int gold_sold;
	int gold_transported<-0;
	agent agent_perceived<-nil;
	
    bool use_social_architecture <- true;
	bool use_emotions_architecture <- true;
	bool use_personality <- true;
	
	float openness <- gauss(0.5,0.12);
	float conscientiousness <- gauss(0.5,0.12);
	float extraversion <- gauss(0.5,0.12);
	float agreeableness <- gauss(0.5,0.12);
	float neurotism <- gauss(0.5,0.12);
	
	float plan_persistence <- 1.0;
	float intention_persistence <- 1.0;
	
	float threshold_law <- 1.0;
	float threshold_obligation <- 1.0;
	float threshold_norm <- 0.5;
	
	init {
		do add_desire(find_gold);
	}
	
	perceive target: self {
		if(gold_transported>0) {
			do add_belief(has_gold);
		} else {
			do remove_belief(has_gold);
		}
	}
	
	perceive target: miner in: view_dist {
		myself.agent_perceived <- self;
		socialize liking: point(my_color.red, my_color.green, my_color.blue) distance_to point(myself.my_color.red, myself.my_color.green, myself.my_color.blue) / ( 255) - 1;
		enforcement norm:"share_information" sanction:"sanction_to_norm" reward:"reward_to_norm";
	}
		
	sanction sanction_to_norm {
		do change_liking(agent_perceived,-0.1);
	}	
	
	sanction reward_to_norm {
		do change_liking(agent_perceived,0.1);
	}
		
	perceive target: gold_mine where (each.quantity > 0) in: view_dist {
		focus id:mine_at_location var:location;
		ask myself {
			if (has_emotion(joy)) {
				write self.name + " is joyous";
				do add_desire(predicate:share_information, strength: 5.0);
			}
			do remove_intention(find_gold, false);
		}
	}
	
	rule belief: has_gold new_desire: sell_gold strength: 3.0;
	
	law working belief: mine_location new_obligation: has_gold when:not has_obligation(has_gold) and not has_belief(has_gold) strength: 2.0 threshold:threshold_law;
	
	plan lets_wander intention:find_gold finished_when: has_desire(has_gold)
	{
		do wander;
	}
	
	norm doing_job obligation:has_gold finished_when: has_belief(has_gold) threshold:threshold_obligation{
		if (target = nil) {
			do add_subintention(get_current_intention(),choose_gold_mine, true);
			do current_intention_on_hold();
		} else {
			do goto target: target ;
			if (target = location)  {
				gold_mine current_mine<- gold_mine first_with (target = each.location);
				if current_mine.quantity > 0 {
					gold_transported <- gold_transported+1;
				 	do add_belief(has_gold);
					ask current_mine {quantity <- quantity - 1;}	
				} else {
					do add_belief(new_predicate(empty_mine_location, ["location_value"::target]));
					do remove_belief(new_predicate(mine_at_location, ["location_value"::target]));
				}
				target <- nil;
			}
		}	
	}
	
	plan get_more_gold intention: has_gold {
		if (target = nil) {
			do add_subintention(get_current_intention(),choose_gold_mine, true);
			do current_intention_on_hold();
		} else {
			do goto target: target ;
			if (target = location)  {
				gold_mine current_mine<- gold_mine first_with (target = each.location);
				if current_mine.quantity > 0 {
					gold_transported <- 3;
				 	do add_belief(has_gold);
					ask current_mine {if(quantity>=3) {
						quantity <- quantity - 3;
					}else {
						quantity <- 0;
					} 
					}	
				} else {
					do add_belief(new_predicate(empty_mine_location, ["location_value"::target]));
					do remove_belief(new_predicate(mine_at_location, ["location_value"::target]));
				}
				target <- nil;
			}
		}	
	}
	
	plan choose_closest_gold_mine intention: choose_gold_mine instantaneous: true{
		list<point> possible_mines <- get_beliefs_with_name(mine_at_location) collect (point(get_predicate(mental_state (each)).values["location_value"]));
		list<point> empty_mines <- get_beliefs_with_name(empty_mine_location) collect (point(get_predicate(mental_state (each)).values["location_value"]));
		possible_mines <- possible_mines - empty_mines;
		if (empty(possible_mines)) {
			do remove_intention(has_gold, true); 
		} else {
			target <- (possible_mines with_min_of (each distance_to self)).location;
		}
		do remove_intention(choose_gold_mine, true); 
	}
	
	plan return_to_base intention: sell_gold when: has_belief(has_gold){
		do goto target: the_market ;
		if (the_market.location = location)  {
			do remove_belief(has_gold);
			do remove_intention(sell_gold, true);
			gold_sold <- gold_sold + gold_transported;
			gold_transported <- 0;
		}
	}
	
	norm share_information intention:share_information threshold:threshold_norm instantaneous: true{
		list<miner> my_friends <- list<miner>((social_link_base where (each.liking > 0)) collect each.agent);
		loop known_gold_mine over: get_beliefs_with_name(mine_at_location) {
			ask my_friends {
				do add_directly_belief(known_gold_mine);
			}
		}
		loop known_empty_gold_mine over: get_beliefs_with_name(empty_mine_location) {
			ask my_friends {
				do add_directly_belief(known_empty_gold_mine);
			}
		}
		
		do remove_intention(share_information, true); 
	}
	
	plan share_information_to_friends intention: share_information instantaneous: true{
		list<miner> my_friends <- list<miner>((social_link_base where (each.liking > 0)) collect each.agent);
		loop known_gold_mine over: get_beliefs_with_name(empty_mine_location) {
			ask my_friends {
				do add_directly_belief(known_gold_mine);
			}
		}		
		do remove_intention(share_information, true); 
	}

	aspect default {
	  draw circle(200) color: my_color border: #black depth: gold_sold;
	  draw circle(view_dist) color: my_color border: #black depth: gold_sold wireframe: true;
	}
}

species socialLinkRepresentation{
	miner origin;
	agent destination;
	rgb my_color;
	
	aspect base{
		draw line([origin,destination],50.0) color: my_color;
	}
}

experiment GoldBdi type: gui {
	output {
		display map type: opengl {
			species market ;
			species gold_mine ;
			species miner;
			species policeman aspect:base;
		}	
		
        display socialLinks type: opengl{
        	species socialLinkRepresentation aspect: base;
    	}

		display chart {
			chart "Money" type: series {
				datalist legend: miner accumulate each.name value: miner accumulate each.gold_sold color: miner accumulate each.my_color;
				data "policeman" value: fine color: #red;
			}
		}
		
	}
}

Back to the start of the tutorial

  1. Creation of the basic model: gold mines and market
  2. Definition of the BDI miners
  3. Definition of social relations between miners
  4. Use of emotions and personality for the miners

Home

  1. What's new (Changelog)

Platform

  1. Installation and Launching
    1. Installation
    2. Launching GAMA
    3. Updating GAMA
    4. Installing Plugins
  2. Workspace, Projects and Models
    1. Navigating in the Workspace
    2. Changing Workspace
    3. Importing Models
  3. Editing Models
    1. GAML Editor (Generalities)
    2. GAML Editor Tools
    3. Validation of Models
  4. Running Experiments
    1. Launching Experiments
    2. Experiments User interface
    3. Controls of experiments
    4. Parameters view
    5. Inspectors and monitors
    6. Displays
    7. Batch Specific UI
    8. Errors View
  5. Running Headless
    1. Headless Batch
    2. Headless Server
    3. Headless Legacy
  6. Preferences
  7. Troubleshooting

Learn GAML step by step

  1. Introduction
    1. Start with GAML
    2. Organization of a Model
    3. Basic programming concepts in GAML
  2. Manipulate basic Species
  3. Global Species
    1. Regular Species
    2. Defining Actions and Behaviors
    3. Interaction between Agents
    4. Attaching Skills
    5. Inheritance
  4. Defining Advanced Species
    1. Grid Species
    2. Graph Species
    3. Mirror Species
    4. Multi-Level Architecture
  5. Defining GUI Experiment
    1. Defining Parameters
    2. Defining Displays Generalities
    3. Defining 3D Displays
    4. Defining Charts
    5. Defining Monitors and Inspectors
    6. Defining Export files
    7. Defining User Interaction
  6. Exploring Models
    1. Run Several Simulations
    2. Batch Experiments
    3. Exploration Methods
  7. Optimizing Model Section
    1. Runtime Concepts
    2. Optimizing Models
  8. Multi-Paradigm Modeling
    1. Control Architecture
    2. Defining Differential Equations

Recipes

  1. Manipulate OSM Data
  2. Diffusion
  3. Using Database
  4. Using FIPA ACL
  5. Using BDI with BEN
  6. Using Driving Skill
  7. Manipulate dates
  8. Manipulate lights
  9. Using comodel
  10. Save and restore Simulations
  11. Using network
  12. Headless mode
  13. Using Headless
  14. Writing Unit Tests
  15. Ensure model's reproducibility
  16. Going further with extensions
    1. Calling R
    2. Using Graphical Editor
    3. Using Git from GAMA

GAML References

  1. Built-in Species
  2. Built-in Skills
  3. Built-in Architecture
  4. Statements
  5. Data Type
  6. File Type
  7. Expressions
    1. Literals
    2. Units and Constants
    3. Pseudo Variables
    4. Variables And Attributes
    5. Operators [A-A]
    6. Operators [B-C]
    7. Operators [D-H]
    8. Operators [I-M]
    9. Operators [N-R]
    10. Operators [S-Z]
  8. Exhaustive list of GAMA Keywords

Developing GAMA

  1. Installing the GIT version
  2. Developing Extensions
    1. Developing Plugins
    2. Developing Skills
    3. Developing Statements
    4. Developing Operators
    5. Developing Types
    6. Developing Species
    7. Developing Control Architectures
    8. Index of annotations
  3. Introduction to GAMA Java API
    1. Architecture of GAMA
    2. IScope
  4. Using GAMA flags
  5. Creating a release of GAMA
  6. Documentation generation

Tutorials

  1. Predator Prey
  2. Road Traffic
  3. 3D Tutorial
  4. Incremental Model
  5. Luneray's flu
  6. BDI Agents

Community

  1. Team
  2. Projects using GAMA
  3. Scientific References
  4. Training Sessions

Versions of GAMA

Resources

  1. Videos
  2. Conferences
  3. Code Examples
  4. Pedagogical materials
Clone this wiki locally