[From Rick Marken (2004.06.07.1130)]
I am going out of town for a couple weeks and will have only
intermittent contact with the net. But before I go I'd like to post an
Excel model of Social Reference Drift so that you can examine and
critique it.
The attached spreadsheet, SocialReorg2.xls, actually implements 6
different models of reference change based on social interaction.
Here's how it works.
The first column in the spreadsheet contains the references for the
perception "Hi" for a population of 100 individuals. The reference for
each individual is a random number between 0 and 99. These references
can be viewed as different specifications for a perception of "Hi". The
assumption is that there are 100 different legitimate ways to say "Hi"
(100 different possible references for the perception "Hi") and each
person in the population want to say "Hi" in one of these ways.
The second column in the spreadsheet shows the reference for each
individual after these individuals have been interacting for a number
of iterations (the number of iterations -- or generations -- being an
input to the program in cell D3; the spreadsheet comes with the number
of iterations set to 200). The individuals interact for the specified
number of iterations when the "Run" button below the graph is pressed.
On each iteration of the program (after the "Run" is pressed) the are
100 "greetings" between randomly selected pairs of individuals in the
population. For each of these 100 greetings, one member of the
population is randomly selected to be the "greeter" and another to be
the "responder". The program makes sure that "greeter" and "responder"
are never the same individual.
The "Model Type" selected for a run determines what happens to the
reference of the greeter and responder after each "greeting". The type
of model is entered into cell H1. The spreadsheet comes with the model
type set to 1, specifying a "G pure control" model. The "G pure
control" model updates the greeter's reference based on the difference
(error) between the greeter's and the responder's way of saying "Hi".
(It is assumed, as it is in Bill William's program, that the reference
corresponds exactly to the output that is produced and perceived. So
error,e, is just the difference between greeter and responder
references). The "pure control" model then updates the greeter's
reference using pure integration: eref(greet) = eref(greet) + e, where
eref(greet) is the greeter's reference on the current iteration.
So the G in the description of Model Type means that only the greeter's
reference is updated after a greeting. G-R in the description of model
type means that the references of both greeter and responder are
updated after a greeting.
The "leaky control" model uses a leaky rather than a pure integration
to update the reference: eref(greet) = eref(greet) + 0.01 * (10 * e -
eref(greet)). The "reorg" model is a "sort of" reorganization model.
The model updates references probabilistically based on the size of the
error; the larger the error, the greater the probability of changing
the reference. It's not real reorganization because when the reference
is updated it is always updated in the "right" direction -- one that
brings the greeter's reference closer to the responder's reference.
Each time you press "Run" the program performs the user specified
number of iterations, running through 100 randomly paired "greetings"
during each of these iterations and updating the references of each
individual involved in the greeting as specified by the model.
At the end of each iteration, the references of all individuals in the
population "drift" randomly in different directions. The average size
of this drift is determined by the value entered for Disturbance
Amplitude (cell F1). If this cell is set to 0 then there is no random
drift at all in references. The value is currently set to 2 (2% of the
range of reference values) which is pretty small but large enough to
keep some of the models from producing results that are "too perfect".
When the run is over the "Reference Distribution" graph shows the
relative frequency of the different references in the population at the
start (Initial) and at the end (Final) of the iterations of
interactions. The distribution of references changes as a result of
these interactions. The changes are different depending on the kind of
model used to update the references. What I find is the following:
The pure control model that updates only the greeter (G pure control)
converges to a narrow distribution of references, the center of this
distribution being different on each run. This seems similar to what
happens in "cultural evolution". Interactions between individuals
results in convergence to some particular way of doing things, but
where the convergence ends up seems random. The population can end up
converging to low, intermediate or high values of references for "Hi".
Where the drift goes is a matter of who tends to interact with who in
the population and this interaction is currently determined randomly.
The leaky control model that updates only the greeter (G pure control)
always converges to a narrow distribution at the low end of the
reference values. This doesn't seem to capture cultural evolution.
Same with the reorg model that update only the greeter (G reorg). This
model (when given enough iterations) seem to converge on intermediate
reference values.
When the references of both greeter and responder are updated, none of
the models seem to give a good representation of cultural evolution.
The pure control model (G-R pure control) doesn't converge; the Final
distribution of references in the population is as flat as the Initial
one. The leaky control model (G-R leaky control) still converges always
to a low reference value and the reorg model (G-R reorg) still
converges to intermediate values.
This, of course, is all very preliminary. I built this model only to
demonstrate an approach to looking at how models of interacting
individuals can be used as the basis of modeling social processes. In
this case, individuals are modeled as control systems that want to
speak (have references for speech perceptions) like others. In one
case, only the greeters change what they want to hear themselves say
(change their reference for "Hi" ) based on how others respond to their
greeting. In the other case, both greeters and responders change what
they want to hear themselves say based on what each member of the dyad
says.
The Visual Basic program that runs the model can be seen by going to
the Visual Basic tool in Excel. But I'm posting it below just in case
people have trouble finding it. It's not pretty; I can already see
ways to tidy it up. But I did this in some haste and I don't have time
to clean it up right now.
I'd like to see what people think of the approach before continuing on
with it. I look forward to hearing constructive suggestions regarding
ways to improve the model.
Best regards
Rick
SocialReorg2.xls (60 KB)
···
---
Sub RunSheet()
Randomize Timer
Dim iref(100), eref(100), f1(20), f2(20)
Application.ScreenUpdating = False
' Initialize References
For i = 1 To 100
Cells(i + 1, 1) = Rnd(3) * 100
iref(i) = Cells(i + 1, 1)
Cells(i + 1, 2) = iref(i)
eref(i) = iref(i)
Next
Rem Calculate Initial Frequency Distribution
For i = 1 To 100
m = Int(iref(i) / 5) + 1
f1(m) = f1(m) + 1
Next i
For i = 1 To 20
Cells(i + 1, 10) = f1(i) / 100
Next i
' Main loop
' Get model type
model = Cells(1, 8)
'Get number of iterations, ni, and disturbance amplitude, amp
ni = Cells(1, 4)
amp = Cells(1, 6)
For i = 1 To ni
For j = 1 To 100
greet = Int(Rnd(3) * 100) + 1
sample:
respond = Int(Rnd(3) * 100) + 1
If greet = respond Then GoTo sample
On model GoTo adapt1, adapt2, adapt3, adapt4, adapt5, adapt6
'Adapt routine 1: greet changes toward respond
' pure integration
adapt1:
e = eref(respond) - eref(greet)
eref(greet) = eref(greet) + e
If eref(greet) > 99 Then eref(greet) = 99
If eref(greet) < 1 Then eref(greet) = 1
GoTo endloop
'Adapt routine 2: greet changes toward respond
'leaky integration
adapt2:
e = eref(respond) - eref(greet)
eref(greet) = eref(greet) + 0.01 * (10 * e - eref(greet))
If eref(greet) > 99 Then eref(greet) = 99
If eref(greet) < 1 Then eref(greet) = 1
GoTo endloop
'Adapt routine 3: greet changes randomly with probability proportional
to e
adapt3:
e = eref(respond) - eref(greet)
'compute probability of change
pr = Abs(e) / (eref(respond) + eref(greet))
If Rnd(3) < pr Then
eref(greet) = eref(greet) + Rnd(3) * e
End If
If eref(greet) > 99 Then eref(greet) = 99
If eref(greet) < 1 Then eref(greet) = 1
'Adapt routine 4: greet and respond changes toward respond
' pure integration
adapt4:
e1 = eref(respond) - eref(greet)
e2 = eref(greet) - eref(respond)
eref(greet) = eref(greet) + e1
eref(respond) = eref(respond) + e2
If eref(greet) > 99 Then eref(greet) = 99
If eref(greet) < 1 Then eref(greet) = 1
If eref(respond) > 99 Then eref(respond) = 99
If eref(respond) < 1 Then eref(respond) = 1
GoTo endloop
'Adapt routine 5: greet and respond changes toward respond
'leaky integration
adapt5:
e1 = eref(respond) - eref(greet)
e2 = eref(greet) - eref(respond)
eref(greet) = eref(greet) + 0.01 * (10 * e1 - eref(greet))
eref(respond) = eref(respond) + 0.01 * (10 * e2 - eref(respond))
If eref(greet) > 99 Then eref(greet) = 99
If eref(greet) < 1 Then eref(greet) = 1
If eref(respond) > 99 Then eref(respond) = 99
If eref(respond) < 1 Then eref(respond) = 1
GoTo endloop
'Adapt routine 6: greet and respond changes randomly with probability
proportional to e
adapt6:
e1 = eref(respond) - eref(greet)
e2 = eref(greet) - eref(respond)
'compute probability of change
pr1 = Abs(e1) / (eref(respond) + eref(greet))
pr2 = Abs(e2) / (eref(respond) + eref(greet))
If Rnd(3) < pr1 Then eref(greet) = eref(greet) + Rnd(3) * e1
If Rnd(3) < pr2 Then eref(respond) = eref(respond) + Rnd(3) * e2
If eref(greet) > 99 Then eref(greet) = 99
If eref(greet) < 1 Then eref(greet) = 1
If eref(respond) > 99 Then eref(respond) = 99
If eref(respond) < 1 Then eref(respond) = 1
endloop:
Next j
'Add noise to population references
For m = 1 To 100
eref(m) = eref(m) + (Rnd(3) - 0.5) * amp
If eref(m) > 99 Then eref(m) = 99
If eref(m) < 1 Then eref(m) = 1
Next m
Next i
For i = 1 To 100
Cells(i + 1, 2) = eref(i)
m = Int(eref(i) / 5) + 1
f2(m) = f2(m) + 1
Next i
For i = 1 To 20
Cells(i + 1, 11) = f2(i) / 100
Next i
Application.ScreenUpdating = True
End Sub
Richard S. Marken
marken@mindreadings.com
Home 310 474-0313
Cell 310 729-1400