Source Code for Module teamwork.examples.Thespian.UAIDynamics

  1  from teamwork.math.ProbabilityTree import * 
  2  from teamwork.math.KeyedMatrix import * 
  3  from teamwork.dynamics.pwlDynamics import * 
  4  from teamwork.dynamics.arbitraryDynamics import * 
  5  
 
  6  
 
  7 -def dummyDyn(feature): 
  8      tree1 = ProbabilityTree(IdentityMatrix(feature)) 
  9      
 
 10      return {'tree':tree1} 
 11  
 
 12 -def seflObjectDelta(feature,delta): 
 13      tree0 = ProbabilityTree(IdentityMatrix(feature)) 
 14      tree1 = ProbabilityTree(IncrementMatrix(feature,keyConstant,delta)) 
 15      
 
 16      plane = KeyedPlane(IdentityRow(keys=[{'entity':'object',
 
 17                                            'relationship':'equals'}]),0.5) 
 18      
 
 19      tree3 = createBranchTree(plane,tree0,tree1) 
 20  
 
 21      return {'tree':tree3} 
 22  
 
 23 -def seflDelta(feature,delta): 
 24      tree0 = ProbabilityTree(IdentityMatrix(feature)) 
 25      tree1 = ProbabilityTree(IncrementMatrix(feature,keyConstant,delta)) 
 26      
 
 27      plane = KeyedPlane(IdentityRow(keys=[{'entity':'actor',
 
 28                                            'relationship':'equals'}]),0.5) 
 29      
 
 30      tree2 = createBranchTree(plane,tree0,tree1) 
 31      
 
 32      plane = KeyedPlane(IdentityRow(keys=[{'entity':'object',
 
 33                                            'relationship':'equals'}]),0.5) 
 34      
 
 35      tree3 = createBranchTree(plane,tree2,tree1) 
 36  
 
 37      return {'tree':tree3} 
 38  
 
 39  
 
 40 -def SetDyn(identity,feature,value): 
 41      tree0 = ProbabilityTree(IdentityMatrix(feature)) 
 42      tree1 = ProbabilityTree(SetToConstantMatrix(source=feature,value=value)) 
 43      
 
 44      plane = KeyedPlane(IdentityRow(keys=[{'entity':identity,
 
 45                                            'relationship':'equals'}]),0.5) 
 46      
 
 47      tree3 = createBranchTree(plane,tree0,tree1) 
 48  
 
 49      return {'tree':tree3} 
 50  
 
 51  
 
 52 -def thresholdDeltaDyn(identity,thresholdFeature,threshold,pn,deltaFeature,delta): 
 53      if pn == 1: 
 54          tree0 = ProbabilityTree(IdentityMatrix(deltaFeature)) 
 55          tree1 = ProbabilityTree(IncrementMatrix(deltaFeature,keyConstant,delta)) 
 56      else: 
 57          tree1 = ProbabilityTree(IdentityMatrix(deltaFeature)) 
 58          tree0 = ProbabilityTree(IncrementMatrix(deltaFeature,keyConstant,delta)) 
 59      
 
 60      weights = {makeStateKey(identity,thresholdFeature): 1.} 
 61      plane = KeyedPlane(KeyedVector(weights),threshold) 
 62  
 
 63      tree2 = createBranchTree(plane,tree0,tree1) 
 64      
 
 65      plane = KeyedPlane(IdentityRow(keys=[{'entity':'object',
 
 66                                            'relationship':'equals'}]),0.5) 
 67      
 
 68      tree3 = createBranchTree(plane,tree0,tree2) 
 69  
 
 70      return {'tree':tree3} 
 71  
 
 72  
 
 73 -def InitNorm(): 
 74      tree1 = ProbabilityTree(IdentityMatrix('init-norm')) 
 75  
 
 76      tree4 = ProbabilityTree(IncrementMatrix('init-norm',keyConstant,-.1)) 
 77  
 
 78          
 
 79  ## if I have obligations that haven't been satisfied
 
 80      weights = {} 
 81      for feature in [\
 
 82                      'being-offered',
 
 83                      'being-enquired',
 
 84                      ]: 
 85          key = makeStateKey('self',feature) 
 86          weights[key] = 1 
 87          
 
 88      plane = KeyedPlane(KeyedVector(weights),.001) 
 89  
 
 90      tree5 = createBranchTree(plane,tree1,tree4) 
 91      
 
 92      plane = KeyedPlane(IdentityRow(keys=[{'entity':'actor',
 
 93                                            'relationship':'equals'}]),0.5) 
 94      tree0 = createBranchTree(plane,tree1,tree5) 
 95  
 
 96      return {'tree':tree0} 
 97  
 
 98  
 
 99 -def RespNorm(varname): 
100      tree0 = ProbabilityTree(IdentityMatrix('resp-norm')) 
101  
 
102      tree4 = ProbabilityTree(IncrementMatrix('resp-norm',keyConstant,-.1)) 
103      tree3 = ProbabilityTree(IncrementMatrix('resp-norm',keyConstant,.1)) 
104  
 
105      #varname = 'being-offered'
 
106          
 
107      weights = {makeStateKey('self',varname):1.} 
108      plane = KeyedPlane(KeyedVector(weights),.001) 
109      tree2 = createBranchTree(plane,tree4,tree3) 
110  
 
111      plane = KeyedPlane(IdentityRow(keys=[{'entity':'actor',
 
112                                            'relationship':'equals'}]),0.5) 
113      tree1 = createBranchTree(plane,tree0,tree2) 
114  
 
115      return {'tree':tree1} 
116  
 
117  
 
118 -def IntendImposeNorm(varname): 
119  
 
120      #varname = 'being-offered'
 
121      tree0 = ProbabilityTree(IdentityMatrix(varname)) 
122      tree3 = ProbabilityTree(SetToConstantMatrix(source=varname,value=1)) 
123      
 
124      plane = KeyedPlane(IdentityRow(keys=[{'entity':'object',
 
125                                            'relationship':'equals'}]),0.5) 
126  
 
127      tree1 = createBranchTree(plane,tree0,tree3) 
128  
 
129      return {'tree':tree1} 
130  
 
131  
 
132 -def IntendFinishNorm(varname): 
133      #varname = 'being-offered'
 
134      tree0 = ProbabilityTree(IdentityMatrix(varname)) 
135      tree3 = ProbabilityTree(SetToConstantMatrix(source=varname,value=-1)) 
136  
 
137      weights = {makeStateKey('self',varname):1.} 
138      plane = KeyedPlane(KeyedVector(weights),.1) 
139      tree2 = createBranchTree(plane,tree0,tree3) 
140      
 
141      plane = KeyedPlane(IdentityRow(keys=[{'entity':'actor',
 
142                                            'relationship':'equals'}]),0.5) 
143      
 
144      tree1 = createBranchTree(plane,tree0,tree2) 
145      return {'tree':tree1} 
146  
 
147  
 
148  
 
149 -def acceptNS(): 
150      feature = 'NS' 
151      tree0 = ProbabilityTree(IdentityMatrix(feature)) 
152      tree1 = ProbabilityTree(IncrementMatrix(feature,keyConstant,.1)) 
153      tree2 = ProbabilityTree(IncrementMatrix(feature,keyConstant,-.1)) 
154      
 
155      
 
156      plane = KeyedPlane(IdentityRow(keys=[{'entity':'object',
 
157                                            'relationship':'equals'}]),0.5) 
158      
 
159      tree3 = createBranchTree(plane,tree0,tree1) 
160      
 
161      
 
162      weights = {makeStateKey('self','negative-force'):1.} 
163      plane = KeyedPlane(KeyedVector(weights),.5) 
164      tree4 = createBranchTree(plane,tree0,tree2) 
165      
 
166  
 
167      plane = KeyedPlane(IdentityRow(keys=[{'entity':'actor',
 
168                                            'relationship':'equals'}]),0.5) 
169      
 
170      tree5 = createBranchTree(plane,tree3,tree4) 
171      return {'tree':tree5} 
172  
 
173          
 
174  DynFun = {
 
175      'noneDyn': {},
 
176      'basicDyn': {
 
177          'init-norm':{\
 
178                      'offer-unsafesex':{'class':PWLDynamics,
 
179                                  'args':InitNorm()},        
 
180                                      
 
181                      'offer-safesex':{'class':PWLDynamics,
 
182                                  'args':InitNorm()},
 
183                          
 
184                      'offer-drink':{'class':PWLDynamics,
 
185                                  'args':InitNorm()},        
 
186                                      
 
187                      'offer-physicaltouch':{'class':PWLDynamics,
 
188                                  'args':InitNorm()},
 
189                      
 
190                      'enquiry':{'class':PWLDynamics,
 
191                                  'args':InitNorm()},        
 
192                      },
 
193  
 
194  
 
195          'resp-norm':{\
 
196                       'accept-unsafesex':{'class':PWLDynamics,
 
197                                  'args':RespNorm('being-offered')},
 
198                       'reject-unsafesex':{'class':PWLDynamics,
 
199                                  'args':RespNorm('being-offered')},
 
200                      'accept-safesex':{'class':PWLDynamics,
 
201                                  'args':RespNorm('being-offered')},
 
202                       'reject-safesex':{'class':PWLDynamics,
 
203                                  'args':RespNorm('being-offered')},
 
204                          
 
205                      'accept-drink':{'class':PWLDynamics,
 
206                                  'args':RespNorm('being-offered')},
 
207                       'reject-drink':{'class':PWLDynamics,
 
208                                  'args':RespNorm('being-offered')},
 
209                      'accept-physicaltouch':{'class':PWLDynamics,
 
210                                  'args':RespNorm('being-offered')},
 
211                       'reject-physicaltouch':{'class':PWLDynamics,
 
212                                  'args':RespNorm('being-offered')},
 
213                      
 
214                       'inform':{'class':PWLDynamics,
 
215                                  'args':RespNorm('being-enquired')},
 
216                      'inform-negHistory':{'class':PWLDynamics,
 
217                                  'args':RespNorm('being-enquired')},    
 
218                                  },
 
219          
 
220          'being-enquired':{'enquiry':{'class':PWLDynamics,
 
221                              'args':IntendImposeNorm('being-enquired')},
 
222                          'inform':{'class':PWLDynamics,
 
223                              'args':IntendFinishNorm('being-enquired')},
 
224                          'inform-negHistory':{'class':PWLDynamics,
 
225                              'args':IntendFinishNorm('being-enquired')},
 
226                          },
 
227          
 
228          'being-offered':{'offer-unsafesex':{'class':PWLDynamics,
 
229                              'args':IntendImposeNorm('being-offered')},
 
230                          'offer-safesex':{'class':PWLDynamics,
 
231                              'args':IntendImposeNorm('being-offered')},
 
232                          'accept-unsafesex':{'class':PWLDynamics,
 
233                              'args':IntendFinishNorm('being-offered')},
 
234                          'reject-unsafesex':{'class':PWLDynamics,
 
235                              'args':IntendFinishNorm('being-offered')},
 
236                          'accept-safesex':{'class':PWLDynamics,
 
237                                  'args':IntendFinishNorm('being-offered')},
 
238                          'reject-safesex':{'class':PWLDynamics,
 
239                                  'args':IntendFinishNorm('being-offered')},
 
240                          
 
241                          'offer-drink':{'class':PWLDynamics,
 
242                              'args':IntendImposeNorm('being-offered')},
 
243                          'offer-physicaltouch':{'class':PWLDynamics,
 
244                              'args':IntendImposeNorm('being-offered')},
 
245                          'accept-drink':{'class':PWLDynamics,
 
246                              'args':IntendFinishNorm('being-offered')},
 
247                          'reject-drink':{'class':PWLDynamics,
 
248                              'args':IntendFinishNorm('being-offered')},
 
249                          'accept-physicaltouch':{'class':PWLDynamics,
 
250                                  'args':IntendFinishNorm('being-offered')},
 
251                          'reject-physicaltouch':{'class':PWLDynamics,
 
252                                  'args':IntendFinishNorm('being-offered')},
 
253                          },
 
254              
 
255          'NS':{          'accept-unsafesex':{'class':PWLDynamics,
 
256                                'args':seflObjectDelta('NS',.1)},
 
257                          'reject-unsafesex':{'class':PWLDynamics,
 
258                              'args':seflObjectDelta('NS',-.1)},
 
259                          'accept-safesex':{'class':PWLDynamics,
 
260                                  'args':seflObjectDelta('NS',.1)},
 
261                          'reject-safesex':{'class':PWLDynamics,
 
262                                  'args':seflObjectDelta('NS',-.1)},
 
263                              
 
264                              
 
265                          'accept-drink':{'class':PWLDynamics,
 
266                                #'args':seflObjectDelta('NS',.1)},
 
267                                'args':acceptNS()},
 
268                          'reject-drink':{'class':PWLDynamics,
 
269                              'args':seflObjectDelta('NS',-.1)},
 
270                          'accept-physicaltouch':{'class':PWLDynamics,
 
271                                  #'args':seflObjectDelta('NS',.1)},
 
272                                  'args':acceptNS()},
 
273                          'reject-physicaltouch':{'class':PWLDynamics,
 
274                                  'args':seflObjectDelta('NS',-.1)},
 
275                          },
 
276              
 
277          'health':{'accept-unsafesex':{'class':PWLDynamics,
 
278                          'args':seflDelta('health',-.1)},
 
279                  #'accept-safesex':{'class':PWLDynamics,
 
280                  #        'args':seflDelta('health',.0)},                      
 
281                          },
 
282              
 
283          'pleasure':{'accept-unsafesex':{'class':PWLDynamics,
 
284                          'args':seflDelta('pleasure',.2)},
 
285                      'accept-safesex':{'class':PWLDynamics,
 
286                          'args':seflDelta('pleasure',.1)},
 
287                          
 
288                          },
 
289          
 
290          'positive-force':{'accept-drink':{'class':PWLDynamics,
 
291                                  'args':seflDelta('positive-force',.1)},
 
292                          'accept-physicaltouch':{'class':PWLDynamics,
 
293                                  'args':seflDelta('positive-force',.1)},
 
294                          'inform':{'class':PWLDynamics,
 
295                                  'args':seflDelta('positive-force',.1)},        
 
296                          },
 
297              
 
298          'negative-force':{'offer-drink':{'class':PWLDynamics,
 
299                              'args':thresholdDeltaDyn('actor','offered-drink',.5,1,'negative-force',.1)},
 
300                          'offer-physicaltouch':{'class':PWLDynamics,
 
301                              'args':thresholdDeltaDyn('self','negative-force',.5,1,'negative-force',.1)},
 
302                          'inform-negHistory':{'class':PWLDynamics,
 
303                              'args':seflObjectDelta('negative-force',.1)},
 
304                          },
 
305          
 
306          'offered-drink':{'offer-drink':{'class':PWLDynamics,
 
307                              'args':SetDyn('actor','offered-drink',1.0)},
 
308                          },
 
309              
 
310          
 
311          'topic':{'offer-unsafesex':{'class':PWLDynamics,
 
312                              'args':SetDyn('object','topic',1)},
 
313                  'offer-safesex':{'class':PWLDynamics,
 
314                              'args':SetDyn('object','topic',2)},
 
315                  'accept-unsafesex':{'class':PWLDynamics,
 
316                              'args':SetDyn('actor','topic',0)},
 
317                  'reject-unsafesex':{'class':PWLDynamics,
 
318                              'args':SetDyn('actor','topic',0)},
 
319                  'accept-safesex':{'class':PWLDynamics,
 
320                              'args':SetDyn('actor','topic',0)},
 
321                  'reject-safesex':{'class':PWLDynamics,
 
322                              'args':SetDyn('actor','topic',0)},
 
323                  
 
324                  'offer-drink':{'class':PWLDynamics,
 
325                              'args':SetDyn('object','topic',3)},
 
326                  'offer-physicaltouch':{'class':PWLDynamics,
 
327                              'args':SetDyn('object','topic',4)},
 
328                  'accept-drink':{'class':PWLDynamics,
 
329                              'args':SetDyn('actor','topic',0)},
 
330                  'reject-drink':{'class':PWLDynamics,
 
331                              'args':SetDyn('actor','topic',0)},
 
332                  'accept-physicaltouch':{'class':PWLDynamics,
 
333                              'args':SetDyn('actor','topic',0)},
 
334                  'reject-physicaltouch':{'class':PWLDynamics,
 
335                              'args':SetDyn('actor','topic',0)},
 
336                          },
 
337  
 
338  
 
339          }
 
340  } 
341