source: cpp/frams/neuro/neuroimpl.cpp @ 197

Last change on this file since 197 was 197, checked in by Maciej Komosinski, 7 years ago

GDK used by developers since 1999, distributed on the web since 2002

  • Property svn:eol-style set to native
File size: 16.8 KB
Line 
1// This file is a part of the Framsticks GDK.
2// Copyright (C) 1999-2014  Maciej Komosinski and Szymon Ulatowski.  See LICENSE.txt for details.
3// Refer to http://www.framsticks.com/ for further information.
4
5#include "neuroimpl.h"
6#include "neurofactory.h"
7#include <frams/util/rndutil.h>
8#include <common/nonstd_math.h>
9#ifndef GDK_WITHOUT_FRAMS
10#include <frams/simul/creature.h>
11#include <frams/mech/creatmechobj.h>
12#include <frams/simul/livegroups.h>
13#include <frams/simul/simul.h>
14#endif
15
16const int NeuroImpl::ENDDRAWING=-9999;
17const int NeuroImpl::MAXDRAWINGXY=0xffff;
18
19int NeuroNetImpl::mytags_id=0;
20
21/////////////////////////////////////////////////////////
22
23#define FIELDSTRUCT NeuroNetConfig
24static ParamEntry nncfg_paramtab[]=
25{
26{"Creature: Neurons",1,3,"nnsim",},
27{"randinit",1,0,"Random initialization","f 0 10 0.01",FIELD(randominit),"Allowed range for initializing all neuron states with uniform distribution random numbers and zero mean. Set to 0 for deterministic initialization."},
28{"nnoise",1,0,"Noise","f 0 1 0",FIELD(nnoise),"Gaussian neural noise: a random value is added to each neural output in each simulation step. Set standard deviation here to add random noise, or 0 for deterministic simulation."},
29{"touchrange",1,0,"T receptor range","f 0 100 1",FIELD(touchrange),},
30{0,0,0,},
31};
32#undef FIELDSTRUCT
33
34NeuroNetConfig::NeuroNetConfig(NeuroFactory *fac)
35        :par(nncfg_paramtab,this),
36         randominit(0.01),
37         nnoise(0),
38         touchrange(1),
39         factory(fac)
40{}
41
42/////////////////////////////////////////////////////////////////
43
44NeuroNetImpl::NeuroNetImpl(Model& model, NeuroNetConfig& conf
45#ifdef NEURO_SIGNALS
46, ChannelSpace *ch
47#endif
48)
49        :mod(model),config(conf),
50         isbuilt(1),errorcount(0)
51#ifdef NEURO_SIGNALS
52,channels(ch)
53#endif
54{
55if (!mytags_id) mytags_id=mod.userdata.newID();
56
57Neuro *n;
58NeuroImpl *ni;
59Joint *j;
60int i;
61DB(printf("makeNeuroNet(%p)\n",&mod));
62
63minorder=3; maxorder=0;
64errorcount=0;
65
66for (i=0;j=mod.getJoint(i);i++)
67        j->flags&=~(4+8); // todo: !!!neuroitems shouldn't use model fields!!!
68
69for (i=0;n=mod.getNeuro(i);i++)
70        {
71        ni=conf.factory->createNeuroImpl(n);
72        n->userdata[mytags_id]=ni;
73        if (!ni) { errorcount++;
74                FMprintf("NeuroNetImpl","create",FMLV_WARN,"neuron #%d (%s) implementation not available",
75                         i,(const char*)n->getClassName());
76                continue; } // implementation not available?!
77        ni->owner=this;
78        ni->neuro=n;
79        ni->readParam();
80        }
81
82for (i=0;n=mod.getNeuro(i);i++)
83        {
84        n->state+=(rnd01-0.5)*config.randominit;
85        ni=(NeuroImpl*)n->userdata[mytags_id];
86        if (!ni) continue;
87        if (!ni->lateinit())
88                { ni->status=NeuroImpl::InitError; errorcount++;
89                FMprintf("NeuroNetImpl","create",FMLV_WARN,"neuron #%d (%s) initialization failed",
90                         i,(const char*)n->getClassName());
91                continue; }
92        ni->status=NeuroImpl::InitOk;
93        int order=ni->getSimOrder();
94        if (order<0) order=0; else if (order>2) order=2;
95        if (order<minorder) minorder=order;
96        if (order>maxorder) maxorder=order;
97        neurons[order]+=ni;
98        if (ni->getNeedPhysics())
99                neurons[3]+=ni;
100        }
101cnode=mod.delmodel_list.add(STATRICKCALLBACK(this,&NeuroNetImpl::destroyNN,0));
102}
103
104void NeuroNetImpl::destroyNN(CALLBACKARGS)
105{
106if (!isbuilt) return;
107DB(printf("destroyNeuroNet(%p)\n",&mod));
108NeuroImpl *ni;
109Neuro *n;
110for (int i=0;n=mod.getNeuro(i);i++)
111        {
112        ni=(NeuroImpl*)n->userdata[mytags_id];
113        delete ni;
114        n->userdata[mytags_id]=0;
115        }
116mod.delmodel_list.remove(cnode);
117isbuilt=0; errorcount=0;
118delete this;
119}
120
121NeuroNetImpl::~NeuroNetImpl()
122{
123destroyNN(0,0);
124}
125
126void NeuroNetImpl::simulateNeuroNet()
127{
128NeuroImpl *ni;
129for (int order=minorder;order<=maxorder;order++)
130        {
131        int i;
132        SList &nlist=neurons[order];
133        for (i=0;ni=(NeuroImpl*)nlist(i);i++)
134                ni->go();
135        for (i=0;ni=(NeuroImpl*)nlist(i);i++)
136                ni->commit();
137        }
138}
139
140void NeuroNetImpl::simulateNeuroPhysics()
141{
142NeuroImpl *ni;
143int i;
144SList &nlist=neurons[3];
145for (i=0;ni=(NeuroImpl*)nlist(i);i++)
146        ni->goPhysics();
147}
148
149///////////////////////////////////////////////
150
151void NeuroImpl::setChannelCount(int c)
152{
153if (c<1) c=1;
154if (c==channels) return;
155if (c<channels) {channels=c; chstate.trim(c-1); chnewstate.trim(c-1); return;}
156double s=getState(channels-1);
157chnewstate.setSize(c-1);
158chstate.setSize(c-1);
159for(int i=channels;i<c;i++)
160        {chstate(i-1)=s; chnewstate(i-1)=s;}
161channels=c;
162}
163
164void NeuroImpl::setState(double st,int channel)
165{
166validateNeuroState(st);
167if (channel>=channels) channel=channels-1;
168if (channel<=0) {newstate=st;return;}
169chnewstate(channel-1)=st;
170}
171
172void NeuroImpl::setCurrentState(double st,int channel)
173{
174validateNeuroState(st);
175if (channel>=channels) channel=channels-1;
176if (channel<=0) {neuro->state=st; return;}
177chstate(channel-1)=st;
178}
179
180double NeuroImpl::getNewState(int channel)
181{
182if (neuro->flags&Neuro::HoldState) return getState(channel);
183if (channel>=channels) channel=channels-1;
184if (channel<=0) {return newstate;}
185return chnewstate(channel-1);
186}
187
188double NeuroImpl::getState(int channel)
189{
190if (channel>=channels) channel=channels-1;
191if (channel<=0) return neuro->state;
192return chstate(channel-1);
193}
194
195void NeuroImpl::commit()
196{
197if (!(neuro->flags&Neuro::HoldState))
198        {
199        if (channels>1)
200                chstate=chnewstate;
201        neuro->state=newstate;
202        if (owner->getConfig().nnoise>0.0)
203                {
204                neuro->state+=RndGen.GaussStd()*owner->getConfig().nnoise;
205                if (channels>1)
206                        for(int i=0;i<chstate.size();i++)
207                                chstate(0)+=RndGen.GaussStd()*owner->getConfig().nnoise;
208                }
209        }
210}
211
212int NeuroImpl::getInputChannelCount(int i)
213{
214if ((i<0)||(i >= neuro->getInputCount())) return 1;
215Neuro *nu=neuro->getInput(i);
216NeuroImpl *ni=NeuroNetImpl::getImpl(nu);
217if (!ni) return 1;
218return ni->channels;
219}
220
221double NeuroImpl::getInputState(int i,int channel)
222{
223if ((i<0)||(i >= neuro->getInputCount())) return 0;
224Neuro *nu=neuro->getInput(i);
225if (channel<=0) return nu->state;
226NeuroImpl *ni=NeuroNetImpl::getImpl(nu);
227if (!ni) return nu->state;
228if (channel>=ni->channels) channel=ni->channels-1;
229if (!channel) return nu->state;
230return ni->chstate(channel-1);
231}
232
233double NeuroImpl::getWeightedInputState(int i, int channel)
234{
235if ((i<0)||(i >= neuro->getInputCount())) return 0;
236double w;
237Neuro *nu=neuro->getInput(i,w);
238if (channel<=0) return nu->state * w;
239NeuroImpl *ni=NeuroNetImpl::getImpl(nu);
240if (!ni) return nu->state * w;
241if (channel>=ni->channels) channel=ni->channels-1;
242if (!channel) return w * nu->state;
243return w * ni->chstate(channel-1);
244}
245
246double NeuroImpl::getInputSum(int startwith)
247{
248if (startwith<0) return 0;
249Neuro *inp;
250double sum=0.0;
251while(inp=neuro->getInput(startwith++))
252        sum+=inp->state;
253return sum;
254}
255
256double NeuroImpl::getWeightedInputSum(int startwith)
257{
258if (startwith<0) return 0;
259Neuro *inp;
260double sum=0.0;
261double w;
262while(inp=neuro->getInput(startwith++,w))
263        sum+=inp->state*w;
264return sum;
265}
266
267void NeuroImpl::readParam()
268{
269Param par;
270if (!paramentries) return;
271par.setParamTab(paramentries);
272par.select(this);
273par.setDefault();
274int zero=0;
275par.load2(neuro->getClassParams(),zero);
276}
277
278Param& NeuroImpl::getStaticParam()
279{
280static Param p(neuroimpl_tab,0,"Neuro");
281return p;
282}
283
284/////////////////////////////
285
286#ifdef NEURO_SIGNALS
287#define NEUROIMPL_SIGNAL_PROPS 1
288#else
289#define NEUROIMPL_SIGNAL_PROPS 0
290#endif
291
292#define FIELDSTRUCT NeuroImpl
293ParamEntry neuroimpl_tab[]=
294{
295{"Neuro",1,27+NEUROIMPL_SIGNAL_PROPS,"Neuro","Live Neuron object."},
296
297{"getInputState",0,0,"Get input signal","p f(d input)",PROCEDURE(p_get),},
298{"getInputWeight",0,0,"Get input weight","p f(d input)",PROCEDURE(p_getweight),},
299{"getWeightedInputState",0,0,"Get weighted input signal","p f(d input)",PROCEDURE(p_getw),},
300{"getInputSum",0,0,"Get signal sum","p f(d input)",PROCEDURE(p_getsum),},
301{"getWeightedInputSum",0,0,"Get weighted signal sum","p f(d input)",PROCEDURE(p_getwsum),"Uses any number of inputs starting with the specified input. getWeightedInputSum(0)=weightedInputSum"},
302{"getInputCount",0,PARAM_READONLY,"Get input count","d",GETONLY(count),},
303{"inputSum",0,PARAM_READONLY,"Full signal sum","f",GETONLY(sum),},
304{"weightedInputSum",0,PARAM_READONLY,"Full weighted signal sum","f",GETONLY(wsum),},
305{"getInputChannelCount",0,0,"Get channel count for input","p d(d input)",PROCEDURE(p_getchancount),},
306{"getInputStateChannel",0,0,"Get input signal from channel","p f(d input,d channel)",PROCEDURE(p_getchan),},
307{"getWeightedInputStateChannel",0,0,"Get weighted input signal from channel","p f(d input,d channel)",PROCEDURE(p_getwchan),},
308{"state",0,0,"Neuron state (channel 0)","f",GETSET(state),"When read, returns the current neuron state.\nWhen written, sets the 'internal' neuron state that will become current in the next step.\nTypically you should use this field, and not currState."},
309{"channelCount",0,0,"Number of output channels","d",GETSET(channels),},
310{"getStateChannel",0,0,"Get state for channel","p f(d channel)",PROCEDURE(p_getstate),},
311{"setStateChannel",0,0,"Set state for channel","p(d channel,f value)",PROCEDURE(p_setstate),},
312{"hold",0,0,"Hold state","d 0 1",GETSET(hold),"\"Holding\" means keeping the neuron state as is, blocking the regular neuron operation. This is useful when your script needs to inject some control signals into the NN. Without \"holding\", live neurons would be constantly overwriting your changes, and the rest of the NN could see inconsistent states, depending on the connections. Setting hold=1 ensures the neuron state will be only set by you, and not by the neuron. The enforced signal value can be set using Neuro.currState before or after setting hold=1. Set hold=0 to resume normal operation.",},
313{"currState",0,0,"Current neuron state (channel 0)","f",GETSET(cstate),"When read, it behaves just like the 'state' field.\nWhen written, changes the current neuron state immediately, which disturbs the regular synchronous NN operation.\nThis feature should only be used while controlling the neuron 'from outside' (like a neuro probe) and not in the neuron definition. See also: Neuro.hold",},
314{"setCurrStateChannel",0,0,"Set current neuron state for channel","p(d channel,f value)",PROCEDURE(p_setcstate),"Analogous to \"currState\"."},
315{"position_x",0,PARAM_READONLY,"Position x","f",GETONLY(position_x),},
316{"position_y",0,PARAM_READONLY,"Position y","f",GETONLY(position_y),},
317{"position_z",0,PARAM_READONLY,"Position z","f",GETONLY(position_z),},
318{"creature",0,PARAM_READONLY,"Gets owner creature","o Creature",GETONLY(creature),},
319{"part",0,PARAM_READONLY,"The Part object where this neuron is located","o MechPart",GETONLY(part),},
320{"joint",0,PARAM_READONLY,"The Joint object where this neuron is located","o MechJoint",GETONLY(joint),},
321{"fields",0,PARAM_READONLY,"Custom neuron fields","o Fields",GETONLY(fields),
322"Neurons can have different fields depending on their class. Script neurons have their fields defined using the \"prop:\" syntax. If you develop a custom neuron script you should use the Fields object for accessing your own neuron fields. The Neuro.fields property is meant for accessing the neuron fields from the outside script.\n"
323"Examples:\n"
324"var c=Populations.createFromString(\"X[N]\");\n"
325"Simulator.print(\"standard neuron inertia=\"+c.getNeuro(0).fields.in);\n"
326"c=Populations.createFromString(\"X[Nn,e:0.1]\");\n"
327"Simulator.print(\"noisy neuron error rate=\"+c.getNeuro(0).fields.e);\n"
328"\n"
329"The Interface object can be used to discover which fields are available for a certain neuron object:\n"
330"c=Populations.createFromString(\"X[N]\");\n"
331"var iobj=Interface.makeFrom(c.getNeuro(0).fields);\n"
332"var i;\n"
333"for(i=0;i<iobj.properties;i++)\n"
334" Simulator.print(iobj.getId(i)+\" (\"+iobj.getName(i)+\")\");",},
335{"def",0,PARAM_READONLY,"Neuron definition from which this live neuron was built","o NeuroDef",GETONLY(neurodef),},
336{"classObject",0,PARAM_READONLY,"Neuron class for this neuron","o NeuroClass",GETONLY(classObject),},
337#ifdef NEURO_SIGNALS
338{"signals",0,PARAM_READONLY,"Signals","o NeuroSignals",FIELD(sigs_obj),},
339#endif
340
341{0,0,0,},
342};
343#undef FIELDSTRUCT
344
345#ifdef NEURO_SIGNALS
346ParamEntry neurosignals_paramtab[]=
347 {
348{"NeuroSignals",1,8,"NeuroSignals","Signals attached to a neuron.\nSee also: Signal, WorldSignals, CreatureSignals.\nscripts/light.neuro and scripts/seelight.neuro are simple custom neuron examples demonstrating how to send/receive signals between creatures.",},
349
350#define FIELDSTRUCT NeuroSignals
351SIGNPAR_ADD(""),
352SIGNPAR_RECEIVE(""),
353SIGNPAR_RECEIVESET(""),
354SIGNPAR_RECEIVEFILTER(""),
355SIGNPAR_RECEIVESINGLE(""),
356#undef FIELDSTRUCT
357
358#define FIELDSTRUCT SignalSet
359SIGNSETPAR_GET,
360SIGNSETPAR_SIZE,
361SIGNSETPAR_CLEAR,
362#undef FIELDSTRUCT
363{0,0,0,},
364 };
365
366Param& NeuroSignals::getStaticParam()
367{
368static Param p(neurosignals_paramtab,0);
369return p;
370}
371#endif
372
373#ifdef NEURO_SIGNALS
374class NeuroSigSource: public SigSource
375{
376  protected:
377NeuroImpl* owner;
378  public:
379NeuroSigSource(NeuroImpl *n,Creature *c):SigSource(0,c),owner(n) {}
380bool update();
381};
382
383bool NeuroSigSource::update()
384{
385Pt3D p;
386if (owner->getPosition(p))
387        {
388        setLocation(p);
389        return true;
390        }
391return false;
392}
393
394Creature *NeuroSignals::getCreature()
395{
396if (!cr)
397        {
398        cr=owner->getCreature();
399        }
400return cr;
401}
402
403void NeuroSignals::p_add(PARAMPROCARGS)
404{
405SigSource *s=new NeuroSigSource(owner,getCreature());
406if (owner->owner->channels)
407        {
408        SigChannel *ch=owner->owner->channels->getChannel(args->getString(),true);
409        ch->addSource(s);
410        }
411else
412        SigChannel::dummy_channel.addSource(s);
413sigs+=s;
414s->setupObject(ret);
415}
416
417void NeuroSignals::p_receive(PARAMPROCARGS)
418{
419SigChannel *ch; Pt3D p;
420if (owner->owner->channels && (ch=owner->owner->channels->getChannel(args->getString(),false)) && owner->getPosition(p))
421        ret->setDouble(ch->receive(&p,getCreature()));
422else
423        ret->setDouble(0);
424}
425
426void NeuroSignals::p_receiveFilter(PARAMPROCARGS)
427{
428SigChannel *ch; Pt3D p;
429if (owner->owner->channels && (ch=owner->owner->channels->getChannel(args[3].getString(),false)) && owner->getPosition(p))
430        ret->setDouble(ch->receive(&p,getCreature(),args[2].getDouble(),args[1].getDouble(),args[0].getDouble()));
431else
432        ret->setDouble(0);
433}
434
435void NeuroSignals::p_receiveSet(PARAMPROCARGS)
436{
437SigChannel *ch; Pt3D p;
438SigVector *vec=new SigVector();
439if (owner->owner->channels && (ch=owner->owner->channels->getChannel(args[1].getString(),false)) && owner->getPosition(p))
440        ch->receiveSet(vec,&p,getCreature(),args[0].getDouble());
441ret->setObject(vec->makeObject());
442}
443
444void NeuroSignals::p_receiveSingle(PARAMPROCARGS)
445{
446SigChannel *ch; Pt3D p;
447if (owner->owner->channels && (ch=owner->owner->channels->getChannel(args[1].getString(),false)) && owner->getPosition(p))
448        {
449        SigSource *src=ch->receiveSingle(&p,getCreature(),args[0].getDouble(),0,1e99);
450        if (src)
451                {
452                src->setupObject(ret);
453                return;
454                }
455        }
456ret->setEmpty();
457}
458#endif
459
460extern ParamEntry creature_paramtab[];
461static Param creature_param(creature_paramtab,0);
462
463Creature* NeuroImpl::getCreature()
464{
465#ifndef GDK_WITHOUT_FRAMS
466CreatMechObject *cmo=(CreatMechObject *)neuro->owner->userdata[CreatMechObject::modeltags_id];
467return cmo->creature;
468#else
469return 0;
470#endif
471}
472
473void NeuroImpl::get_creature(ExtValue *ret)
474{
475#ifndef GDK_WITHOUT_FRAMS
476ret->setObject(ExtObject(&creature_param,getCreature()));
477#endif
478}
479
480void NeuroImpl::get_part(ExtValue *ret)
481{
482#ifndef GDK_WITHOUT_FRAMS
483Part *pa;
484if (pa=neuro->getPart())
485        ret->setObject(ExtObject(&MechPart::getStaticParam(),((MechPart *)pa->userdata[CreatMechObject::modeltags_id])));
486else
487        ret->setEmpty();
488#endif
489}
490
491void NeuroImpl::get_joint(ExtValue *ret)
492{
493#ifndef GDK_WITHOUT_FRAMS
494Joint *jo;
495if (jo=neuro->getJoint())
496        ret->setObject(ExtObject(&MechJoint::getStaticParam(),((MechJoint*)jo->userdata[CreatMechObject::modeltags_id])));
497else
498        ret->setEmpty();
499#endif
500}
501
502bool NeuroImpl::getPosition(Pt3D &pos)
503{
504#ifndef GDK_WITHOUT_FRAMS
505Part *pa; Joint *jo;
506if (pa=neuro->getPart())
507        {pos=((MechPart *)pa->userdata[CreatMechObject::modeltags_id])->p; return true;}
508if (jo=neuro->getJoint())
509        {
510        if (neuro->getClass()->getVisualHints() & NeuroClass::AtFirstPart)
511                pos=((MechPart*)jo->part1->userdata[CreatMechObject::modeltags_id])->p;
512        else if (neuro->getClass()->getVisualHints() & NeuroClass::AtSecondPart)
513                pos=((MechPart*)jo->part2->userdata[CreatMechObject::modeltags_id])->p;
514        else pos=(((MechPart*)jo->part1->userdata[CreatMechObject::modeltags_id])->p
515                   +((MechPart*)jo->part2->userdata[CreatMechObject::modeltags_id])->p)/2;
516        return true;
517        }
518#endif
519return false;
520}
521
522void NeuroImpl::get_position_x(ExtValue *ret)
523{Pt3D pos; if (getPosition(pos)) ret->setDouble(pos.x); else ret->setEmpty();}
524void NeuroImpl::get_position_y(ExtValue *ret)
525{Pt3D pos; if (getPosition(pos)) ret->setDouble(pos.y); else ret->setEmpty();}
526void NeuroImpl::get_position_z(ExtValue *ret)
527{Pt3D pos; if (getPosition(pos)) ret->setDouble(pos.z); else ret->setEmpty();}
528
529
530void NeuroImpl::createFieldsObject()
531{
532fields_param=new Param(paramentries?paramentries:(ParamEntry*)&empty_paramtab,this,"Fields");
533fields_object=new ExtObject(fields_param);
534}
535
536void NeuroImpl::get_fields(ExtValue *ret)
537{
538if (!fields_object)
539        createFieldsObject();
540ret->setObject(*fields_object);
541}
542
543void NeuroImpl::get_neurodef(ExtValue *ret)
544{
545ret->setObject(ExtObject(&Neuro::getStaticParam(),neuro));
546}
547
548void NeuroImpl::get_classObject(ExtValue *ret)
549{
550#ifndef GDK_WITHOUT_FRAMS
551NeuroClassExt::makeStaticObject(ret,neuroclass);
552#endif
553}
554
555NeuroImpl::~NeuroImpl()
556{
557if (fields_param)
558        {
559        delete fields_param;
560        delete fields_object;
561        }
562}
Note: See TracBrowser for help on using the repository browser.