@Article{HinricksForbus2011,
  author = 	 {Hinricks, Thomas R., and Forbus, Kenneth D.},
  title = 	 {Transfer learning through analogy in games},
  journal =  	 {AI Magazine},
  year = 	 {2011},
  volume = 	 {32},
  number = 	 {1},
  pages = 	 {70-83}
}

• Analogy speeds up transfer learning in game domains
• “Minimal ascension” and “metamapping” enable analogies between domains with different vocabularies [p.70]
• Near transfer: exact transfer of knowledge between similar domains [p.70]
• Far transfer: transfer of knowledge (via abstraction) between highly different domains [p.70]
• Analogical transfer: transfer of learned knowledge from the source domain to a target domain through the use of analogy [p.71]
• Structure mapping: process of analogy that specifies which statements map onto each other [p.71]
• Goal of transfer learning research is to increase the success of knowledge transfer across non-similar domains [p.72]
• Learning results in the creation of strategies for winning the game, organized in a “hierarchical task network (HTN)” [p.73]
• When HTN’s are successfully transferred from one game to another, that game is learned faster and with less trial and error.

1. Analyze initial conditions of the game, parameters like health, and spatial relations to “create a declarative understanding” [p.74] of the game, including actions and effects
2. Rename all predicates with a prefix that is specific to the game (so source and target predicates are never the same) - ensures far transfer is being tested
3. Create “elaborated structural representations” [p.75]: classify predicates as actions, ordinal relations, spatial coordinates, types, or quantities (this constrains the search space for learning strategies during experimentation)
4. Goal analysis (top-down process): Look at the end state of the game, and figure out what the goal is in order to win the game. Identify subgoals, and whether or not they can be achieved independently [p. 75]

• learn how entities in the game behave
• learn when to use different actions
• learn how goals decompose into subgoals

1. During the game, go through the “game execution trace” [p. 76] to determine which experiments led to good or bad actions. If good, determine how to achieve in future. If bad, put "nogood constraint” [p.76] to avoid it.
2. Based on this, different plans are constructed to achieve certain effects. Ex: effect --> able to shoot, task --> go to gun [p. 76]
3. After winning game, create a high-level HTN: order subtasks in hierarchy that will result in winning game, replace specific coordinates and directions with general spatial relations, removed strategies whose outcomes were never used

1. some primitives (leaves of HTN) which are run first invoke “doPlan operator”, so that after each step replanning occurs to accommodate "unforeseen effects of actions and adversarial responses" [p.76-77]
2. specific action sequences are turned into hierarchical network of subtasks. This way, each task is a hierarchy, and if some action method doesn't transfer properly, it alone can be rejected without tossing the entire task
3. "lifting" [p.77]: replacing constants with variables (e.g. spec coordinates replaced with descriptions "exit") so that they can be analogically mapped to target entities

1. static analysis of target game
2. analogical mapping and transfer (from source domain)
3. Transferred strategies that fail in target domain are removed and replaced by learning goals

• "minimal ascension" eliminates need for predicates to be identical by allowing matches between statements whose predicates share a "superordinate" [p.71]
• uses the predicate classifications generated from static analysis to identify potential matches
• e.g. “Scroll” and “potion” are game-specific predicates. Static analysis determines that they both define types, so they are classified as “ggpTypePredicate”, and can be mapped. (Fig.11) [p.78]

• "metamapping" allows matching where no predicates are identical [p.71]
• compares all structural properties (features and relationships with other predicates) of predicates to find which are alike. Structural info used here comes from the static domain analysis (Fig.12) [p.78]