Game-World Pattern Mining (2013 Archive)

From OpenCog
Jump to: navigation, search

The page is a historical archive of a 2013 description of how pattern mining can be applied to discover movement patterns and behavior patterns in a virtual-avatar Unity3D game world. The ideas sketched here underpinned Shujing Ke's PhD thesis work, performed during this time-frame.

Simple Game-World Patterns

This page gathers some relatively simple examples of patterns that we'd like an early version of a pattern miner to be able to mine from an Atomspace built up from the Unity3D game world...

Along with a conceptual description of each pattern, is supposed to be added a formalization of the pattern in Atom syntax, and a discussion of additional concepts/processes that might be desirable to optimally support that pattern.

METHODOLOGY

The methodology being followed on this page is to reduce each pattern to a form that has only ONE free variable, by introducing ancillary concepts or predicates that make any other complexities (that otherwise would require more than one free variable) go away.

This requires some creativity sometimes, but, it seems to be a worthwhile process, in that the ancillary concepts and predicates seem like ones worth having form more general reasons. This seems not a bad heuristic for building in some common-sensical concepts and predicates, i.e.: Build in ones that will make commonplace/commonsense patterns in the world as simple and straightforward as possible!

When I am near Lake [some specific character], my happiness level [generally] increases

This can be expressed as

Implication
  AtTime
     Evaluation near I Lake
     $T
  AtTime
     Evaluation SubjectiveMomentIncrease happiness
     $T

which has only one variable, time…

The ancillary predicate, SubjectiveMomentIncrease, can be defined as

Equivalence
   AtTime
      Evaluation SubjectiveMomentIncrease $X
      $T
   AtTime
      Evaluation ScaledIncrease $X subjective_moment_lag subjective_gain
      $T

where

Equivalence
   AtTime
      Evaluation ScaledIncrease $X scale_value gain_value
      T
   AND
      AtTime
         Evaluation IsTVStrengthOf $X $S1
         T
      AtTime
         Evaluation IsTVStrengthOf $X $S2
         ExecutionOutput - T scale_value
      Evaluation FuzzyGreaterThan $S1 $S2 gain_value
 

Here:

  • the parameter subjective_moment_lag tells: over how many seconds does something have to increase, to feel subjectively to the agent like "at this moment it's increasing."
  • the parameter subjective_gain tells: how much increase does there need to be, for a truth-value increase to feel to the system like an increase?
  • the predicate IsTVStrengthOf should be self-explanatory …
  • the predicate FuzzyGreaterThan is defined so that, for instance ...
FuzzyGreaterThan x y <s>

is f(x-y) where

f(infinity) = 1
f(z) = 0 if z<0
f(0) = 0

For z>0,  f(z) = tanh(gain_value * z) 

When I am near some [any] other character, my novelty goal is [generally] more strongly fulfilled

A straightforward version (with only one variable, time) would be

Implication
  AtTime
     ThereExists $Y
        Inheritance $Y GameWorldCharacter
	Evaluation near I $Y
     $T
  AtTime
     Evaluation SubjectiveMomentIncrease NoveltyFeeling
     $T


A simpler version would be

Implication
  AtTime
     Evaluation NearCategory GameWorldCharacter
     $T
  AtTime
     Evaluation SubjectiveMomentIncrease NoveltyFeeling
     $T


Here I have introduced the ancillary predicate NearCategory defined via

Implication
  AtTime
     NearCategory $C
     $T
  AtTime
     ThereExists $Y
       AND
          Inheritance $Y $C
          Evaluation near I $Y
     $T

and also the category GameWorldPerson with obvious semantics.

Leaf blocks and wood blocks are often found near each other

Most straightforward, logic-ish version

A straightforward rendition of this pattern would be:

Implication
   AND
      Inheritance $X block
      Inheritance $X leaf
   ThereExists $Y
      AND
         Evaluation $Y block
         Evaluation $Y wood
         Evaluation near $X $Y

A different, complementary approach would be to add a process that auto-creates a concept RegionContains X for common X in the game world.

The semantics would be, e.g.

Equivalence
   Evaluation RegionContainsCategory $C $R
   Evaluation
      Some
      Implication
          PhysicalPartLink $X $R
          Inheritance $X $C

(and this semantics could also be explicitly encoded in the Atomspace via Scheme)

Then the needed pattern looks like

Implication
  Evaluation RegionContainsCategory LeafBlocks $X
   ThereExists $Y
      AND
         Evaluation RegionContainsCategory WoodBlocks $Y
         Evaluation Near $X $Y

There could then also be a process that creates RegionContainsCategory X relations pertaining to regions that contain a lot of X (according to some appropriate heuristics -- e.g. the relations could be made for maximal connected regions containing a lot of X)...

The advantage of the region-based approach is that there are going to be fewer interesting regions than blocks, so the search for patterns becomes easier/faster...

Simple version

It also occurs to me that a simpler version of this pattern would be, merely

AND
     Evaluation RegionContainsCategory LeafBlocks $X
     Evaluation RegionContainsCategory WoodBlocks $X

That avoids the nasty ThereExists and has only one variable ... though it relies utterly on the ancillary Region nodes...

I suspect this is the way to go. It's a good illustration about how building up a reasonable domain ontology of concepts, makes the patterns that need to be mined simpler in expression, which makes mining more tractable.

When Bob comes near a battery, Bob often picks up the battery

PredictiveImplication
   AND
     Inheritance $X battery
     Evaluation near $X Bob
  Evaluation PickUp Bob $X

This one is pretty easy, assuming we have a predicate for PickUp, grounded in observations in the game world....

When Bob comes near a battery, the battery often disappears from my sight

A simple rendition would be

PredictiveImplication
   AND
     Inheritance $X battery
     Evaluation near $X Bob
   Inheritance $X UnknownLocation

This relies on the ancillary concept UnknownLocation, which we could build in, and which would be defined like

Equivalence
  Inheritance $X UnknownLocation
  NOT
     Evaluation
        know
        I
        Evaluation LocalWorldLocation $X $Y
Implication
   Evaluation
      Some 
      TruthValueStrength $X
   Evaluation know I $X

Here it's assumed that

  • Some is a GroundedPredicateNode implementing a fuzzy truth value function
  • LocalWorldLocation is a GroundedPredicateNode tied in with the SpaceMap

When a character moves from a lower point to a higher point, a ladder object is sometimes involved

One rendition, with a single variable, would be:

AND
   Inheritance $X GameWorldCharacter
   HebbianLink
      Ladder
       Evaluation
          EverydayTimeScaleIncrease
          ExecutionOutput HeightOf $X


Note that, here, the temporal association is wrapped up in the HebbianLink...

We need the HeightOf predicate, which is simple enough

The predicate EverydayTimeScaleIncrease may be defined via

Equivalence
   AtTime
      Evaluation EverydayTimeScaleIncrease $X
      $T
   ThereExists $L
      AND
         Evaluation EverydayTimeScale $L
         AtTime
            Evaluation ScaledIncrease $X $L everyday_timescale_gain
            $T

where the gain may be 1, and the predicate EverydayTimeScale is a fuzzy time distribution that is True for time-values $L that are on the everyday scale, e.t.

Evaluation EverydayTimeScale $L <1>
if $L is between one second and one day

Evaluation EverydayTimeScale $L <.001>
if $L is one microsecond

Evaluation EverydayTimeScale $L <.001>
if $L is a decade