[Swarm-Modelling] Re: Modelling digest, Vol 1 #46 - 1 msg

[Kanagaraj Krishna]

Would it be posibble for me to get the codes for the party model please. Thanks

Kana
--

--------- Original Message ---------

DATE: Tue, 27 May 2003 12:00:06
From: address@hidden
To: address@hidden
Cc: 

>Send Modelling mailing list submissions to
>       address@hidden
>
>To subscribe or unsubscribe via the World Wide Web, visit
>       http://www.swarm.org/mailman/listinfo/modelling
>or, via email, send a message with subject or body 'help' to
>       address@hidden
>
>You can reach the person managing the list at
>       address@hidden
>
>When replying, please edit your Subject line so it is more specific
>than "Re: Contents of Modelling digest..."
>
>
>Today's Topics:
>
>   1. Re: Re: [Swarm-Support] Re: Agent communication and grid models (Doug 
> Donalson)
>
>--__--__--
>
>Message: 1
>From: "Doug Donalson" <address@hidden>
>To: <address@hidden>
>Subject: Re: [Swarm-Modelling] Re: [Swarm-Support] Re: Agent communication and 
>grid models
>Date: Tue, 27 May 2003 10:10:11 -0700
>Reply-To: address@hidden
>
>Just for reference.  The more common term for "soup" models is  "mean
>field".
>
>Cheers,
>
>D4
>
>----- Original Message -----
>From: "Darren Schreiber" <address@hidden>
>To: <address@hidden>
>Sent: Tuesday, May 27, 2003 2:40 AM
>Subject: Re: [Swarm-Modelling] Re: [Swarm-Support] Re: Agent communication
>and grid models
>
>
>>
>> I explained the "soup" model in the parenthetical phrase after I used
>> the term.  It means that all agents are capable of interacting with all
>> other agents.  Like Russell said, you could think of this as a similar
>> metaphor to the primordial soup.  If you had pasted shaped like letters
>> of the alphabet floating in "alphabet soup" with a stir any letter
>> could be adjacent to any other letter.
>>
>> I think that the reason many people use grid models is because the
>> classes are there or that this is just what they have seen other people
>> do.  In many models I have looked at, the grid is not substantively
>> motivated, which is a pretty big problem in my mind and lends credence
>> to the concern that ABM's are just video games.  So, again I would
>> think about what your problem of interest is like and build your model
>> accordingly.  For my housing segregation model, there were both
>> historic (docking with Schelling's models and other followups) and
>> substantive (people don't really live on a torus) reasons for using a
>> grid.  But, again I think that the conceptual model should lead the
>> programming not vice versa.
>>
>> Soup models can be displayed graphically.  For me, the idea of a GUI
>> (graphic user interface) means that I am given some buttons and stuff
>> to click when running the model.  Even models where the output is just
>> text can be controlled from a GUI.
>>
>> I think your question is whether one can display soup models
>> graphically.  Take a look at my webpage (www.bol.ucla.edu/~dschreib)
>> and follow the links on the party model.  What I am using there is the
>> "canvas" display.  This is one way of visualizing the interactions of
>> agents not located on a grid.  In my party model, the X and Y
>> dimensions represent two of the possible dimensions in the issue space.
>>   Each of the little circles is a "node" representing an agent.  When
>> the model is running, you can click on a node to probe the agent and
>> find out what its current properties are.  The color of the node tell
>> you what kind of agent it is, the color of the ring around the agent
>> tells you what main coalition the agent belongs to, and the thickness
>> of the ring around the agent tells you how high up in the hierarchy the
>> agent is (thicker means more senior).  The lines going from node to
>> node are called links and represent the connections among agents.
>>
>> So this is one way of visualizing the interaction among agents.  But
>> again, I would suggest that you think about the substantive issues you
>> are exploring and motivate the visualization from that.  What is it
>> that you want to know about the agents, their behavior, their choices,
>> and their rewards?  If this were my project, I would brainstorm all the
>> questions that I might want to ask of this model and think about what
>> the data needed to address those questions would look like.  I would
>> also suggest that you look into some of the books by Edward Tufte
>> (http://www.edwardtufte.com) about the visual display of information.
>> He is utterly amazing in his deep thinking about the issues involved in
>> visualizing data.  Following his insights will increase the likelihood
>> that you can make sense of the model you are creating.  It would be
>> very cool if my models generated graphics like "The Sims", but it might
>> not give me any insight into the model and in fact might make it harder
>> for people to see what is really going on.
>>
>> Releasing slave agents to get the best offers wouldn't be hard at all.
>> There are no specific functions.  But this would be very simple to do
>> once you have gotten the gist of using Swarm.  To amend my algorithm
>> below, I would give my buyerAgents some threshold where they would
>> decide that an offer is "good enough" and thus constrain how much
>> effort it is willing to expend in going to its known traders, the
>> traders of friends, or the random other traders.  I would have the
>> buyerAgent build a list of all the offers it receives from other agents
>> and then just sort that from best to worst.  Then, I'd have my
>> buyerAgent accept the best off.
>>
>> The bottom line is that Swarm can definitely do what you want to do.
>> But, I think you'll need to think more about the problem before you go
>> writing code.  Also, I think that your deep thinking about the problem
>> will make it easier for you to learn the programming skills you'll need
>> to solve the particular problems you are interested in.  In my view,
>> programming is the easy part, good modeling is much harder.
>>
>> My method for modeling is to brainstorm my most ambitious version of
>> the model to answer all the questions I could desire.  With all of
>> these possibilities laid out before me, I then start to categorize them
>> and prioritize them.  Then I start looking for common issues that are
>> at the core of the phenomena of interest.  And, I imagine the very
>> simplest version of the model that is a first step toward the ambitious
>> one.  Usually, my first models (version 0.00.01) simply creates a few
>> agents and has them print their ID numbers.  From there, I add feature
>> after feature, debugging carefully along the way, making sure that I
>> understand the behavior of the model at each step.  This also means
>> that I don't have to learn all of the programming issues involved at
>> once, I can just learn enough to take the next very very small step.
>>
>> Best of luck.
>>
>> Darren
>>
>>
>> On Monday, May 26, 2003, at 11:16  PM, Kanagaraj Krishna wrote:
>>
>> > Hi,
>> >    Can i know in detail what is meant by a "soup" model. Any such
>> > examples available (java preferably)?
>> > It would be nice if I could get your codes too, for reference.
>> >
>> > I've seen most examples of SWARM with GUI simulation (bugs etc..)
>> > where grids were used. Can a "soup" model be presented in a GUI
>> > simulation too?
>> >
>> > Another one question .........would it be possible for an agent to
>> > release a few other slave agents (sub agents) to go and get the best
>> > offers from different traders and then compare&decide. Is this
>> > posibble in SWARM.......i mean any specific functions available.
>> >
>> > Thanks.
>> >
>> > Kana
>> > --
>> >
>> > --------- Original Message ---------
>> >
>> > DATE: Mon, 26 May 2003 15:48:31
>> > From: Darren Schreiber <address@hidden>
>> > To: address@hidden
>> > Cc: address@hidden
>> >
>> >> I'm following this up on the modelling list only, so reply there.  My
>> >> code is in the Objective-C version of Swarm, but let me know if you'd
>> >> like to look at it.
>> >>
>> >> What I am reading from your description of the society you want to
>> >> model indicates that you really aren't looking for a "topological"
>> >> solution.  Rather, I would guess that you are wanting what is
>> >> sometimes
>> >> called a "soup" model, where all agents are capable of interaction
>> >> with
>> >> any other agent.
>> >>
>> >> What I would do is this:
>> >>
>> >> Creation Phase:
>> >> 1.  As all traderAgents are created, you place them onto a
>> >> traderAllList.
>> >>
>> >> 2.  All buyerAgents are put onto a buyerAllList
>> >>
>> >> 3.   Each buyerAgent will be created with its own traderList of known
>> >> other traders (initially empty) and its own friendsList of other
>> >> agents
>> >> that it trusts (also empty.)
>> >>
>> >> 4,  Each traderAgent is created with its own buyerList and its own
>> >> friendsList (both empty.)
>> >>
>> >> Simulation Phase:
>> >>
>> >> 1.  As each buyerAgent is called, it either randomly sorts its
>> >> traderList or it sorts the list by trust rating.  Then the buyer
>> >> iterates through the traderList to see if it can trade with each
>> >> agent.
>> >>
>> >> 2.  If unsuccessful with its traderList, it sorts its friendsList
>> >> (either randomly or according to trust) and iterates through the
>> >> friendsList, asking each friendAgent to recommend a traderAgent.  If I
>> >> were designing it, I would make the askAFriend method recursive, so
>> >> that I can ask a friend to ask his friends to ask his friends (etc.).
>> >> You may initially only want to ask your close friends, but I could
>> >> imagine it would be worth parameterizing the friendsDepth option (0:
>> >> my
>> >> friends, 1: friends of my friends, 2: friends of my friends' friends,
>> >> etc) to explore the importance of the social network depth.
>> >>
>> >> 3.  If unable to find a suitable trading partner from either my
>> >> traderList or the lists of my friends, then my buyerAgent would
>> >> randomly sample from the traderAllList.
>> >>
>> >> So, since you not really using any physical construct of distance, I
>> >> would definitely avoid using a grid.  In fact, you will probably want
>> >> to visualize the model with just a series of graphs and maybe a
>> >> probeable display of agents (so you can study the performance of a
>> >> particular agent.)
>> >>
>> >> Darren
>> >>
>> >>
>> >> On Monday, May 26, 2003, at 11:16 AM, Kanagaraj Krishna wrote:
>> >>
>> >>> Hi,
>> >>> Thanks for the input. Are you're simulation codes  available for me
>> >>> to
>> >>> have a look at. I prefer refering to java examples of SWARM, so that
>> >>> it would be easier for me to integate into my work.
>> >>>
>> >>> Regarding how my model works. This models will simulate the
>> >>> management
>> >>> of trust among agents in a multi agent trading environment (more
>> >>> applicable to internet.....e-commerce etc). I'll play around with the
>> >>> parameters to study the behaviour of my new model.
>> >>>
>> >>> I'll give a brief outline of how the agents in the society works.
>> >>>
>> >>> -buyer agents gives priority to known trader agents first, when
>> >>> sending slave agents to do trading. (experience based trust ratings)
>> >>> -next if there hasn't been any experience with a trader agent
>> >>> before........the buyer agents will ask its trusted friends for
>> >>> support. (trust based on reputation/recommendation)
>> >>> -and the last choice is to explore and take risk with the unknown
>> >>> trader agent.
>> >>> -the same vice versa for the trader agents in choosing a buyer.
>> >>>
>> >>> Any comments.
>> >>>
>> >>> Thanks again,
>> >>> Kana
>> >>> --
>> >>>
>> >>> --------- Original Message ---------
>> >>>
>> >>> DATE: Mon, 26 May 2003 00:57:15
>> >>> From: Darren Schreiber <address@hidden>
>> >>> To: address@hidden, address@hidden
>> >>> Cc:
>> >>>
>> >>>> (I am cross posting this to the modeling list, since my discussion
>> >>>> is
>> >>>> more on the theory than code related.  If your thoughts are on the
>> >>>> modeling side, you'd get more interesting replies by following it up
>> >>>> there.)
>> >>>>
>> >>>> There are a lot of possible topologies that you can use, not just
>> >>>> grids.  If I were you, I would think more about the substantive
>> >>>> problem
>> >>>> and what kind of model topology you think would best describe the
>> >>>> real
>> >>>> world problems you are interested in studying.
>> >>>>
>> >>>> Grids are nice because they are easy to visualize and it is pretty
>> >>>> easy
>> >>>> to manage proximity and distance.  Plus, there are pre-existing
>> >>>> examples you can work from.  But, you might also specify a hex (six
>> >>>> sided) grid since you don't have the "corner" problem of square
>> >>>> grids.
>> >>>>
>> >>>> In some of my work, I have used both square grids and continuous
>> >>>> spaces.  My political party model envisions agents with positions on
>> >>>> diverse number of political issues.  Each issue dimension runs from
>> >>>> 0
>> >>>> to 100, and since I use floating points to represent the position,
>> >>>> agents can be anywhere along that continuum (i.e. they are not
>> >>>> constrained to position 1, 5, or 10, but could be 1.20348 or
>> >>>> 5.294842).
>> >>>>
>> >>>> But, because of the nature of the political world I am interested in
>> >>>> modeling, I did not want to constrain my agents to a single issue
>> >>>> dimension.  So, I set the model up to handle an arbitrary number of
>> >>>> issues.  In later versions of this model (coming soon (like 6 months
>> >>>> or
>> >>>> so)), this model will be used to illustrate how we have one
>> >>>> ideological
>> >>>> dimension (left to right) emerge out of a space containing many
>> >>>> issue
>> >>>> dimensions.  Thus, the space that my agents traverse is a
>> >>>> multidimensional one.
>> >>>>
>> >>>> Furthermore, because not all political issues are equally
>> >>>> important, I
>> >>>> have altered the geometry of the space so that distance is not the
>> >>>> typical Euclidean measure, but is instead a weighted Euclidean
>> >>>> distance
>> >>>> where some dimensions are viewed as more important than others.
>> >>>> Similarly, since a bundle of political issues might be related to
>> >>>> each
>> >>>> other (not independent) I allow the separability of the dimensions
>> >>>> to
>> >>>> be changed.  Both of these tricks are accomplished by sticking a
>> >>>> little
>> >>>> matrix of weights into the standard Euclidean distance measure.
>> >>>> And,
>> >>>> since not everyone agrees about the salience or separability of
>> >>>> issues,
>> >>>> I allow every agent in my model to have its own perceptions of the
>> >>>> topology of the political universe.  I may thus view our political
>> >>>> positions as very similar, but you might view them as very
>> >>>> different.
>> >>>> This creates a relativistic geometry quite different than the
>> >>>> Cartesian
>> >>>> grids that we learn in high school.
>> >>>>
>> >>>> Rather than starting with coding constraints, I started with the
>> >>>> substantive problem, worked towards a plausible model, sketched some
>> >>>> concepts, and then got into the coding.  Because my design is
>> >>>> heavily
>> >>>> parameterized, I can represent a simple two dimensional space with
>> >>>> integer values like a grid or a high dimensional relativistic
>> >>>> geometry
>> >>>> using the same code.
>> >>>>
>> >>>> To manage communication and agent interaction, I put all of the
>> >>>> agents
>> >>>> onto a list as they were created.  All agents have the ability to
>> >>>> send
>> >>>> and get messages.  To find nearby agents, they look through the list
>> >>>> of
>> >>>> all agents and calculate the distance to each agent.  My agents also
>> >>>> have the ability to form hierarchical networks, so they have a list
>> >>>> of
>> >>>> agents below them and above them in the hierarchy.
>> >>>>
>> >>>> Now, the method of searching a list of all agents is not optimized
>> >>>> in
>> >>>> terms of coding, but I am willing to sacrifice that for the
>> >>>> flexibility
>> >>>> that my model has in representing my substantive beliefs.
>> >>>> Furthermore,
>> >>>> it isn't hard to think of some ways of creating subdivided the agent
>> >>>> lists to make it faster to find adjacent agents.
>> >>>>
>> >>>> So, what I would do is think about the substantive problem you are
>> >>>> representing.  When your buyer sends out his representatives, is he
>> >>>> asking them to walk down the street to talk to other traders?  Are
>> >>>> they
>> >>>> getting in planes and flying to another city or country?  Or, are
>> >>>> they
>> >>>> staying behind the desk and working the phone lines cold calling
>> >>>> perspective traders?  Or, perhaps the representatives exist in a
>> >>>> social
>> >>>> network of other agents who know other agents?
>> >>>>
>> >>>> In my view, the programming issues here are much simpler than than
>> >>>> modeling issues.  And, you are more likely to useful help on the
>> >>>> programming once you know what you want.  As far as Swarm is
>> >>>> concerned,
>> >>>> it is incredibly flexible (good enough to handle my relativistic
>> >>>> hyper-dimensional hierarchically networked topology).
>> >>>>
>> >>>> Darren
>> >>>>
>> >>>>
>> >>>> On Sunday, May 25, 2003, at 10:57  PM, Kanagaraj Krishna wrote:
>> >>>>
>> >>>>> Hi,
>> >>>>>
>> >>>>> -Are there any SWARM examples that involves interaction between
>> >>>>> agents
>> >>>>> (commuication) that can help me in designing my model (java ones).
>> >>>>> Example: one buyer agent release few slave agents to interact with
>> >>>>> few
>> >>>>> trader agents to do business and then come back to report.
>> >>>>>
>> >>>>> -Most of the examples used the grid/lattice way of designing
>> >>>>> models......are this the only way?
>> >>>>>
>> >>>>> -Are there any specific functions for an agent to look for another
>> >>>>> specific agent in a world? how can this be done?
>> >>>>>
>> >>>>> I was looking into the CharlesJavaTutorial examples on bugs looking
>> >>>>> for food. It is more straight forward and there is no interaction
>> >>>>> between agents.Thanks.
>> >>>>>
>> >>>>> Regards,
>> >>>>> Kana
>> >>>>>
>> >>>>>
>> >>>>> ____________________________________________________________
>> >>>>> Get advanced SPAM filtering on Webmail or POP Mail ... Get Lycos
>> >>>>> Mail!
>> >>>>> http://login.mail.lycos.com/r/referral?aid=27005
>> >>>>> _______________________________________________
>> >>>>> Support mailing list
>> >>>>> address@hidden
>> >>>>> http://www.swarm.org/mailman/listinfo/support
>> >>>>>
>> >>>>
>> >>>> _______________________________________________
>> >>>> Support mailing list
>> >>>> address@hidden
>> >>>> http://www.swarm.org/mailman/listinfo/support
>> >>>>
>> >>>
>> >>>
>> >>>
>> >>> ____________________________________________________________
>> >>> Get advanced SPAM filtering on Webmail or POP Mail ... Get Lycos
>> >>> Mail!
>> >>> http://login.mail.lycos.com/r/referral?aid=27005
>> >>> _______________________________________________
>> >>> Modelling mailing list
>> >>> address@hidden
>> >>> http://www.swarm.org/mailman/listinfo/modelling
>> >>>
>> >>
>> >>
>> >
>> >
>> >
>> > ____________________________________________________________
>> > Get advanced SPAM filtering on Webmail or POP Mail ... Get Lycos Mail!
>> > http://login.mail.lycos.com/r/referral?aid=27005
>> > _______________________________________________
>> > Modelling mailing list
>> > address@hidden
>> > http://www.swarm.org/mailman/listinfo/modelling
>> >
>>
>> _______________________________________________
>> Modelling mailing list
>> address@hidden
>> http://www.swarm.org/mailman/listinfo/modelling
>
>
>
>
>--__--__--
>
>_______________________________________________
>Modelling mailing list
>address@hidden
>http://www.swarm.org/mailman/listinfo/modelling
>
>
>End of Modelling Digest
>



____________________________________________________________
Get advanced SPAM filtering on Webmail or POP Mail ... Get Lycos Mail!
http://login.mail.lycos.com/r/referral?aid=27005