Existence040.java

Package: existence/
File: Existence040.java

  1. package existence;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import agent.Anticipation;
  6. import agent.Anticipation031;
  7. import coupling.Experiment;
  8. import coupling.Experiment040;
  9. import coupling.Result;
  10. import coupling.interaction.Interaction;
  11. import coupling.interaction.Interaction030;
  12. import coupling.interaction.Interaction040;
  13.  
  14. /** 
  15. * Existence040 implements two-step self-programming.
  16. */
  17. public class Existence040 extends Existence031 {
  18.  
  19. 	private Interaction040 previousSuperInteraction;
  20. 	private Interaction040 lastSuperInteraction;
  21.  
  22. 	@Override
  23. 	protected void initExistence(){
  24. 		Experiment040 e1 = (Experiment040)addOrGetExperience(LABEL_E1);
  25. 		Experiment040 e2 = (Experiment040)addOrGetExperience(LABEL_E2);
  26. 		Result r1 = createOrGetResult(LABEL_R1);
  27. 		Result r2 = createOrGetResult(LABEL_R2);
  28. 		/** Change the valence depending on the environment to obtain better behaviors */
  29. 		Interaction040 e11 = (Interaction040)addOrGetPrimitiveInteraction(e1, r1, -1);
  30. 		Interaction040 e12 = (Interaction040)addOrGetPrimitiveInteraction(e1, r2, 1); // Use valence 1 for Environment040 and 2 for Environment041
  31. 		Interaction040 e21 = (Interaction040)addOrGetPrimitiveInteraction(e2, r1, -1);
  32. 		Interaction040 e22 = (Interaction040)addOrGetPrimitiveInteraction(e2, r2, 1); // Use valence 1 for Environment040 and 2 for Environment041
  33. 		e1.setIntendedInteraction(e12); e1.resetAbstract();
  34. 		e2.setIntendedInteraction(e22); e2.resetAbstract();
  35. 	}
  36.  
  37. 	@Override
  38. 	public String step() {
  39.  
  40. 		List<Anticipation> anticipations = anticipate();
  41. 		Experiment040 experience =  (Experiment040)selectExperience(anticipations);
  42.  
  43. 		Interaction040 intendedInteraction = experience.getIntendedInteraction();
  44.  
  45. 		Interaction040 enactedInteraction = enact(intendedInteraction);
  46. 		System.out.println("Enacted "+ enactedInteraction.toString());
  47.  
  48. 		if (enactedInteraction != intendedInteraction && experience.isAbstract()){
  49. 			Result failResult = createOrGetResult(enactedInteraction.getLabel().replace('e', 'E').replace('r', 'R') + ">");
  50. 			int valence = enactedInteraction.getValence(); 
  51. 			enactedInteraction = (Interaction040)addOrGetPrimitiveInteraction(experience, failResult, valence);
  52. 		}
  53.  
  54. 		if (enactedInteraction.getValence() >= 0)
  55. 			this.setMood(Mood.PLEASED);
  56. 		else
  57. 			this.setMood(Mood.PAINED);
  58.  
  59. 		this.learnCompositeInteraction(enactedInteraction);
  60.  
  61. 		this.setPreviousSuperInteraction(this.getLastSuperInteraction());
  62. 		this.setEnactedInteraction(enactedInteraction);
  63.  
  64. 		return "" + this.getMood();
  65. 	}
  66.  
  67. 	/**
  68. 	 * Learn composite interactions from 
  69. 	 * the previous super interaction, the context interaction, and the enacted interaction
  70. 	 */
  71. 	@Override
  72. 	public void learnCompositeInteraction(Interaction030 enactedIntearction){
  73. 		Interaction040 previousInteraction = this.getEnactedInteraction(); 
  74. 		Interaction040 lastInteraction = (Interaction040)enactedIntearction;
  75. 		Interaction040 previousSuperInteraction = this.getPreviousSuperInteraction();
  76. 		Interaction040 lastSuperIntearction = null;
  77.         // learn [previous current] called the super interaction
  78. 		if (previousInteraction != null)
  79. 			lastSuperIntearction = addOrGetAndReinforceCompositeInteraction(previousInteraction, lastInteraction);
  80.  
  81. 		// Learn higher-level interactions
  82.         if (previousSuperInteraction != null 
  83.         		//&& previousInteraction.isPrimitive() && lastInteraction.isPrimitive()
  84.         		){	
  85.             // learn [penultimate [previous current]]
  86.             this.addOrGetAndReinforceCompositeInteraction(previousSuperInteraction.getPreInteraction(), lastSuperIntearction);
  87.             // learn [[penultimate previous] current]
  88.             this.addOrGetAndReinforceCompositeInteraction(previousSuperInteraction, lastInteraction);
  89.         }
  90.         this.setLastSuperInteraction(lastSuperIntearction);
  91. 	}
  92.  
  93. 	public Interaction040 addOrGetAndReinforceCompositeInteraction(Interaction030 preInteraction, Interaction030 postInteraction){
  94. 		Interaction040 compositeInteraction = addOrGetCompositeInteraction(preInteraction, postInteraction);
  95. 		compositeInteraction.incrementWeight();
  96. 		if (compositeInteraction.getWeight() == 1)
  97. 			System.out.println("learn " + compositeInteraction.toString());
  98. 		else
  99. 			System.out.println("reinforce " + compositeInteraction.toString());
  100.  
  101. 		return compositeInteraction;
  102. 	}
  103.  
  104. 	/**
  105. 	 * Records or get a composite interaction in memory
  106. 	 * If a new composite interaction is created, then a new abstract experience is also created and associated to it.
  107. 	 * @param preInteraction: The composite interaction's pre-interaction
  108. 	 * @param postInteraction: The composite interaction's post-interaction
  109. 	 * @return the learned composite interaction
  110. 	 */
  111. 	@Override
  112. 	public Interaction040 addOrGetCompositeInteraction(Interaction030 preInteraction, Interaction030 postInteraction) {
  113. 		String label = "<" + preInteraction.getLabel() + postInteraction.getLabel() + ">";
  114.         Interaction040 interaction = (Interaction040)getInteraction(label);
  115.         if (interaction == null){
  116. 			interaction = (Interaction040)addOrGetInteraction(label); 
  117. 			interaction.setPreInteraction(preInteraction);
  118. 			interaction.setPostInteraction(postInteraction);
  119. 			interaction.setValence(preInteraction.getValence() + postInteraction.getValence());
  120. 			this.addOrGetAbstractExperience(interaction);
  121. 			//interaction.setExperience(abstractExperience);
  122.         }
  123.     	return interaction;
  124. 	}
  125.  
  126.     public Experiment040 addOrGetAbstractExperience(Interaction040 interaction) {
  127.         String label = interaction.getLabel().replace('e', 'E').replace('r', 'R').replace('>', '|');
  128.         if (!EXPERIENCES.containsKey(label)){
  129.         	Experiment040 abstractExperience =  new Experiment040(label);
  130.         	abstractExperience.setIntendedInteraction(interaction);
  131. 			interaction.setExperience(abstractExperience);
  132.             EXPERIENCES.put(label, abstractExperience);
  133.         }
  134.         return (Experiment040)EXPERIENCES.get(label);
  135.     }
  136.  
  137. 	@Override
  138. 	protected Interaction040 createInteraction(String label){
  139. 		return new Interaction040(label);
  140. 	}
  141.  
  142. 	/**
  143. 	 * Get the list of activated interactions
  144. 	 * from the enacted Interaction, the enacted interaction's post-interaction if any, 
  145. 	 * and the last super interaction
  146. 	 * @param the enacted interaction
  147. 	 * @return the list of anticipations
  148. 	 */
  149. 	@Override
  150. 	public List<Interaction> getActivatedInteractions() {
  151.  
  152. 		List<Interaction> contextInteractions = new ArrayList<Interaction>();
  153.  
  154. 		if (this.getEnactedInteraction()!=null){
  155. 			contextInteractions.add(this.getEnactedInteraction());
  156. 			if (!this.getEnactedInteraction().isPrimitive())
  157. 				contextInteractions.add(this.getEnactedInteraction().getPostInteraction());
  158. 			if (this.getLastSuperInteraction() != null)
  159. 				contextInteractions.add(this.getLastSuperInteraction());
  160. 		}
  161.  
  162. 		List<Interaction> activatedInteractions = new ArrayList<Interaction>();
  163. 		for (Interaction interaction : this.INTERACTIONS.values()){
  164. 			Interaction040 activatedInteraction = (Interaction040)interaction;
  165. 			if (!activatedInteraction.isPrimitive())
  166. 				if (contextInteractions.contains(activatedInteraction.getPreInteraction())){
  167. 					activatedInteractions.add(activatedInteraction);
  168. 					System.out.println("activated " + activatedInteraction.toString());
  169. 				}
  170. 		}
  171. 		return activatedInteractions;
  172. 	}	
  173.  
  174. 	@Override
  175. 	protected List<Anticipation> getDefaultAnticipations(){
  176. 		List<Anticipation> anticipations = new ArrayList<Anticipation>();
  177. 		for (Experiment experience : this.EXPERIENCES.values()){
  178. 			Experiment040 defaultExperience = (Experiment040)experience;
  179. 			if (!defaultExperience.isAbstract()){
  180. 				Anticipation031 anticipation = new Anticipation031(experience, 0);
  181. 				anticipations.add(anticipation);
  182. 			}
  183. 		}
  184. 		return anticipations;
  185. 	}
  186.  
  187. 	public Interaction040 enact(Interaction030 intendedInteraction){
  188.  
  189. 		if (intendedInteraction.isPrimitive())
  190. 			return enactPrimitiveIntearction(intendedInteraction);
  191. 		else {			
  192. 			// Enact the pre-interaction
  193. 			Interaction040 enactedPreInteraction = enact(intendedInteraction.getPreInteraction());
  194. 			if (!enactedPreInteraction.equals(intendedInteraction.getPreInteraction()))
  195. 				// if the preInteraction failed then the enaction of the intendedInteraction is interrupted here.
  196. 				return enactedPreInteraction;
  197. 			else{
  198. 				// Enact the post-interaction
  199. 				Interaction040 enactedPostInteraction = enact(intendedInteraction.getPostInteraction());
  200. 				return (Interaction040)addOrGetCompositeInteraction(enactedPreInteraction, enactedPostInteraction);
  201. 			}
  202. 		}
  203. 	}
  204.  
  205. 	/**
  206. 	 * Implements the cognitive coupling between the agent and the environment
  207. 	 * @param intendedPrimitiveInteraction: The intended primitive interaction to try to enact against the environment
  208. 	 * @param The actually enacted primitive interaction.
  209. 	 */
  210. 	public Interaction040 enactPrimitiveIntearction(Interaction030 intendedPrimitiveInteraction){
  211. 		Experiment experience = intendedPrimitiveInteraction.getExperience();
  212. 		/** Change the returnResult() to change the environment 
  213. 		 *  Change the valence of primitive interactions to obtain better behaviors */		
  214. 		//Result result = returnResult010(experience);
  215. 		//Result result = returnResult030(experience);
  216. 		//Result result = returnResult031(experience);
  217. 		Result result = returnResult040(experience);
  218. 		//Result result = returnResult041(experience);
  219. 		return (Interaction040)this.addOrGetPrimitiveInteraction(experience, result);
  220. 	}
  221.  
  222. 	@Override
  223. 	protected Experiment040 createExperience(String label){
  224. 		return new Experiment040(label);
  225. 	}
  226.  
  227. 	@Override
  228. 	public Interaction040 getEnactedInteraction(){
  229. 		return (Interaction040)super.getEnactedInteraction();
  230. 	}
  231. 	public Interaction040 getPreviousSuperInteraction() {
  232. 		return previousSuperInteraction;
  233. 	}
  234. 	public void setPreviousSuperInteraction(Interaction040 previousSuperInteraction) {
  235. 		this.previousSuperInteraction = previousSuperInteraction;
  236. 	}
  237. 	public Interaction040 getLastSuperInteraction() {
  238. 		return lastSuperInteraction;
  239. 	}
  240. 	public void setLastSuperInteraction(Interaction040 lastSuperInteraction) {
  241. 		this.lastSuperInteraction = lastSuperInteraction;
  242. 	}
  243.  
  244. 	/**
  245. 	 * Environment040
  246. 	 * Results in R2 when the current experience equals the previous experience and differs from the penultimate experience.
  247. 	 * and in R1 otherwise.
  248. 	 * e1->r1 e1->r2 e2->r1 e2->r2 etc. 
  249. 	 */
  250. 	private Experiment penultimateExperience;
  251. 	protected void setPenultimateExperience(Experiment penultimateExperience){
  252. 		this.penultimateExperience = penultimateExperience;
  253. 	}
  254. 	protected Experiment getPenultimateExperience(){
  255. 		return this.penultimateExperience;
  256. 	}
  257.  
  258. 	public Result returnResult040(Experiment experience){
  259.  
  260. 		Result result = this.createOrGetResult(this.LABEL_R1);
  261.  
  262. 		if (this.getPenultimateExperience() != experience &&
  263. 			this.getPreviousExperience() == experience)
  264. 			result =  this.createOrGetResult(this.LABEL_R2);
  265.  
  266. 		this.setPenultimateExperience(this.getPreviousExperience());
  267. 		this.setPreviousExperience(experience);
  268.  
  269. 		return result;
  270. 	}
  271.  
  272. 	/**
  273. 	 * Environment041
  274. 	 * The agent must alternate experiences e1 and e2 every third cycle to get one r2 result the third time:
  275. 	 * e1->r1 e1->r1 e1->r2 e2->r1 e2->r1 e2->r2 etc. 
  276. 	 */
  277. 	protected Experiment antepenultimateExperience;
  278. 	protected void setAntePenultimateExperience(Experiment antepenultimateExperience){
  279. 		this.antepenultimateExperience = antepenultimateExperience;
  280. 	}
  281. 	protected Experiment getAntePenultimateExperience(){
  282. 		return this.antepenultimateExperience;
  283. 	}
  284.  
  285. 	public Result returnResult041(Experiment experience){
  286.  
  287. 		Result result = this.createOrGetResult(this.LABEL_R1);
  288.  
  289. 		if (this.getAntePenultimateExperience() != experience &&
  290. 			this.getPenultimateExperience() == experience &&
  291. 			this.getPreviousExperience() == experience)
  292. 			result =  this.createOrGetResult(this.LABEL_R2);
  293.  
  294. 		this.setAntePenultimateExperience(this.getPenultimateExperience());
  295. 		this.setPenultimateExperience(this.getPreviousExperience());
  296. 		this.setPreviousExperience(experience);
  297.  
  298. 		return result;
  299. 	}
  300.  
  301. }
  302.  

See public discussions about this page or start a new discussion by clicking on the Google+ Share button. Please type the #IDEALMOOCExistence040 hashtag in your post: