source: cpp/frams/genetics/oper_fx.cpp @ 760

Last change on this file since 760 was 758, checked in by Maciej Komosinski, 6 years ago

Added a few useful functions providing lists of neurons with specific properties

  • Property svn:eol-style set to native
File size: 11.6 KB
Line 
1// This file is a part of Framsticks SDK.  http://www.framsticks.com/
2// Copyright (C) 1999-2018  Maciej Komosinski and Szymon Ulatowski.
3// See LICENSE.txt for details.
4
5#include <ctype.h>  //isupper()
6#include "oper_fx.h"
7#include <common/log.h>
8#include <common/nonstd_math.h>
9#include <frams/util/rndutil.h>
10
11static double distrib_force[] =   // for '!'
12{
13        3,             // distribution 0 -__/ +1
14        0.001, 0.2,    // "slow" neurons
15        0.001, 1,
16        1, 1,          // "fast" neurons
17};
18static double distrib_inertia[] =  // for '='
19{
20        2,             // distribution 0 |..- +1
21        0, 0,          // "fast" neurons
22        0.7, 0.98,
23};
24static double distrib_sigmo[] =  // for '/'
25{
26        5,             // distribution -999 -..-^-..- +999
27        -999, -999,    //"perceptron"
28        999, 999,
29        -5, -1,        // nonlinear
30        1, 5,
31        -1, 1,         // ~linear
32};
33
34
35int GenoOperators::roulette(const double *probtab, const int count)
36{
37        double sum = 0;
38        int i;
39        for (i = 0; i < count; i++) sum += probtab[i];
40        double sel = rnd01*sum;
41        for (sum = 0, i = 0; i < count; i++) { sum += probtab[i]; if (sel < sum) return i; }
42        return -1;
43}
44
45bool GenoOperators::getMinMaxDef(ParamInterface *p, int i, double &mn, double &mx, double &def)
46{
47        mn = mx = def = 0;
48        int defined = 0;
49        if (p->type(i)[0] == 'f')
50        {
51                double _mn = 0, _mx = 1, _def = 0.5;
52                defined = p->getMinMaxDouble(i, _mn, _mx, _def);
53                if (defined == 1) _mx = _mn + 1.0;
54                if (_mx < _mn && defined == 3) _mn = _mx = _def; //only default was defined, let's assume min=max=default
55                if (defined < 3) _def = (_mn + _mx) / 2.0;
56                mn = _mn; mx = _mx; def = _def;
57        }
58        if (p->type(i)[0] == 'd')
59        {
60                paInt _mn = 0, _mx = 1, _def = 0;
61                defined = p->getMinMaxInt(i, _mn, _mx, _def);
62                if (defined == 1) _mx = _mn + 1;
63                if (_mx < _mn && defined == 3) _mn = _mx = _def; //only default was defined, let's assume min=max=default
64                if (defined < 3) _def = (_mn + _mx) / 2;
65                mn = _mn; mx = _mx; def = _def;
66        }
67        return defined == 3;
68}
69
70int GenoOperators::selectRandomProperty(Neuro* n)
71{
72        int neuext = n->extraProperties().getPropCount(),
73                neucls = n->getClass() == NULL ? 0 : n->getClass()->getProperties().getPropCount();
74        if (neuext + neucls == 0) return -1; //no properties in this neuron
75        int index = randomN(neuext + neucls);
76        if (index >= neuext) index = index - neuext + 100;
77        return index;
78}
79
80double GenoOperators::mutateNeuProperty(double current, Neuro *n, int i)
81{
82        if (i == -1) return mutateCreepNoLimit('f', current, 2, true); //i==-1: mutating weight of neural connection
83        Param p;
84        if (i >= 100) { i -= 100; p = n->getClass()->getProperties(); }
85        else p = n->extraProperties();
86        double newval = current;
87        /*bool ok=*/getMutatedProperty(p, i, current, newval);
88        return newval;
89}
90
91bool GenoOperators::mutatePropertyNaive(ParamInterface &p, int i)
92{
93        double mn, mx, df;
94        if (p.type(i)[0] != 'f' && p.type(i)[0] != 'd') return false; //don't know how to mutate
95        getMinMaxDef(&p, i, mn, mx, df);
96
97        ExtValue ev;
98        p.get(i, ev);
99        ev.setDouble(mutateCreep(p.type(i)[0], ev.getDouble(), mn, mx, true));
100        p.set(i, ev);
101        return true;
102}
103
104bool GenoOperators::mutateProperty(ParamInterface &p, int i)
105{
106        double newval;
107        ExtValue ev;
108        p.get(i, ev);
109        bool ok = getMutatedProperty(p, i, ev.getDouble(), newval);
110        if (ok) { ev.setDouble(newval); p.set(i, ev); }
111        return ok;
112}
113
114bool GenoOperators::getMutatedProperty(ParamInterface &p, int i, double oldval, double &newval)
115{
116        newval = 0;
117        if (p.type(i)[0] != 'f' && p.type(i)[0] != 'd') return false; //don't know how to mutate
118        const char *n = p.id(i), *na = p.name(i);
119        if (strcmp(n, "si") == 0 && strcmp(na, "Sigmoid") == 0) newval = CustomRnd(distrib_sigmo); else
120                if (strcmp(n, "in") == 0 && strcmp(na, "Inertia") == 0) newval = CustomRnd(distrib_inertia); else
121                        if (strcmp(n, "fo") == 0 && strcmp(na, "Force") == 0) newval = CustomRnd(distrib_force); else
122                        {
123                double mn, mx, df;
124                getMinMaxDef(&p, i, mn, mx, df);
125                newval = mutateCreep(p.type(i)[0], oldval, mn, mx, true);
126                        }
127        return true;
128}
129
130double GenoOperators::mutateCreepNoLimit(char type, double current, double stddev, bool limit_precision_3digits)
131{
132        double result = RndGen.Gauss(current, stddev);
133        if (type == 'd')
134        {
135                result = int(result + 0.5);
136                if (result == current) result += randomN(2) * 2 - 1; //force some change
137        }
138        else
139        {
140                if (limit_precision_3digits)
141                        result = floor(result * 1000 + 0.5) / 1000.0; //round
142        }
143        return result;
144}
145
146double GenoOperators::mutateCreep(char type, double current, double mn, double mx, double stddev, bool limit_precision_3digits)
147{
148        double result = mutateCreepNoLimit(type, current, stddev, limit_precision_3digits);
149        //TODO consider that when boundary is touched (reflect+absorb below), the requested precision (3 digits) may change. Is it good or bad?
150        //reflect:
151        if (result > mx) result = mx - (result - mx); else
152                if (result < mn) result = mn + (mn - result);
153        //absorb (just in case 'result' exceeded the allowed range so much):
154        if (result > mx) result = mx; else
155                if (result < mn) result = mn;
156        return result;
157}
158
159double GenoOperators::mutateCreep(char type, double current, double mn, double mx, bool limit_precision_3digits)
160{
161        double stddev = (mx - mn) / 2 / 5; // magic arbitrary formula for stddev, which becomes /halfinterval, 5 times narrower
162        return mutateCreep(type, current, mn, mx, stddev, limit_precision_3digits);
163}
164
165void GenoOperators::setIntFromDoubleWithProbabilisticDithering(ParamInterface &p, int index, double value) //TODO
166{
167        p.setInt(index, (paInt)(value + 0.5)); //TODO value=2.499 will result in 2 and 2.5 will result in 3, but we want these cases to be 2 or 3 with almost equal probability. value=2.1 should be mostly 2, rarely 3. Careful with negative values (test it!)
168}
169
170void GenoOperators::linearMix(vector<double> &p1, vector<double> &p2, double proportion)
171{
172        if (p1.size() != p2.size())
173        {
174                logPrintf("GenoOperators", "linearMix", LOG_ERROR, "Cannot mix vectors of different length (%d and %d)", p1.size(), p2.size());
175                return;
176        }
177        for (unsigned int i = 0; i < p1.size(); i++)
178        {
179                double v1 = p1[i];
180                double v2 = p2[i];
181                p1[i] = v1*proportion + v2*(1 - proportion);
182                p2[i] = v2*proportion + v1*(1 - proportion);
183        }
184}
185
186void GenoOperators::linearMix(ParamInterface &p1, int i1, ParamInterface &p2, int i2, double proportion)
187{
188        char type1 = p1.type(i1)[0];
189        char type2 = p2.type(i2)[0];
190        if (type1 == 'f' && type2 == 'f')
191        {
192                double v1 = p1.getDouble(i1);
193                double v2 = p2.getDouble(i2);
194                p1.setDouble(i1, v1*proportion + v2*(1 - proportion));
195                p2.setDouble(i2, v2*proportion + v1*(1 - proportion));
196        }
197        else
198                if (type1 == 'd' && type2 == 'd')
199                {
200                int v1 = p1.getInt(i1);
201                int v2 = p2.getInt(i2);
202                setIntFromDoubleWithProbabilisticDithering(p1, i1, v1*proportion + v2*(1 - proportion));
203                setIntFromDoubleWithProbabilisticDithering(p2, i2, v2*proportion + v1*(1 - proportion));
204                }
205                else
206                        logPrintf("GenoOperators", "linearMix", LOG_WARN, "Cannot mix values of types '%c' and '%c'", type1, type2);
207}
208
209NeuroClass* GenoOperators::getRandomNeuroClass()
210{
211        vector<NeuroClass*> active;
212        for (int i = 0; i < Neuro::getClassCount(); i++)
213                if (Neuro::getClass(i)->genactive)
214                        active.push_back(Neuro::getClass(i));
215        if (active.size() == 0) return NULL; else return active[randomN(active.size())];
216}
217
218NeuroClass* GenoOperators::getRandomNeuroClassWithOutput()
219{
220        vector<NeuroClass*> active;
221        for (int i = 0; i < Neuro::getClassCount(); i++)
222                if (Neuro::getClass(i)->genactive && Neuro::getClass(i)->getPreferredOutput() != 0)
223                        active.push_back(Neuro::getClass(i));
224        if (active.size() == 0) return NULL; else return active[randomN(active.size())];
225}
226
227NeuroClass* GenoOperators::getRandomNeuroClassWithInput()
228{
229        vector<NeuroClass*> active;
230        for (int i = 0; i < Neuro::getClassCount(); i++)
231                if (Neuro::getClass(i)->genactive && Neuro::getClass(i)->getPreferredInputs() != 0)
232                        active.push_back(Neuro::getClass(i));
233        if (active.size() == 0) return NULL; else return active[randomN(active.size())];
234}
235
236NeuroClass* GenoOperators::getRandomNeuroClassWithOutputAndNoInputs()
237{
238        vector<NeuroClass*> active;
239        for (int i = 0; i < Neuro::getClassCount(); i++)
240                if (Neuro::getClass(i)->genactive && Neuro::getClass(i)->getPreferredOutput() != 0 && Neuro::getClass(i)->getPreferredInputs() == 0)
241                        active.push_back(Neuro::getClass(i));
242        if (active.size() == 0) return NULL; else return active[randomN(active.size())];
243}
244
245int GenoOperators::getRandomNeuroClassWithOutput(const vector<NeuroClass*>& NClist)
246{
247        vector<int> allowed;
248        for (size_t i = 0; i < NClist.size(); i++)
249                if (NClist[i]->getPreferredOutput() != 0) //this NeuroClass provides output
250                        allowed.push_back(i);
251        if (allowed.size() == 0) return -1; else return allowed[randomN(allowed.size())];
252}
253
254int GenoOperators::getRandomNeuroClassWithInput(const vector<NeuroClass*>& NClist)
255{
256        vector<int> allowed;
257        for (size_t i = 0; i < NClist.size(); i++)
258                if (NClist[i]->getPreferredInputs() != 0) //this NeuroClass wants one input connection or more                 
259                        allowed.push_back(i);
260        if (allowed.size() == 0) return -1; else return allowed[randomN(allowed.size())];
261}
262
263int GenoOperators::getRandomChar(const char *choices, const char *excluded)
264{
265        int allowed_count = 0;
266        for (size_t i = 0; i < strlen(choices); i++) if (!strchrn0(excluded, choices[i])) allowed_count++;
267        if (allowed_count == 0) return -1; //no char is allowed
268        int rnd_index = randomN(allowed_count) + 1;
269        allowed_count = 0;
270        for (size_t i = 0; i < strlen(choices); i++)
271        {
272                if (!strchrn0(excluded, choices[i])) allowed_count++;
273                if (allowed_count == rnd_index) return i;
274        }
275        return -1; //never happens
276}
277
278NeuroClass* GenoOperators::parseNeuroClass(char*& s)
279{
280        int maxlen = (int)strlen(s);
281        int NClen = 0;
282        NeuroClass *NC = NULL;
283        for (int i = 0; i<Neuro::getClassCount(); i++)
284        {
285                const char *ncname = Neuro::getClass(i)->name.c_str();
286                int ncnamelen = (int)strlen(ncname);
287                if (maxlen >= ncnamelen && ncnamelen>NClen && (strncmp(s, ncname, ncnamelen) == 0))
288                {
289                        NC = Neuro::getClass(i);
290                        NClen = ncnamelen;
291                }
292        }
293        s += NClen;
294        return NC;
295}
296
297Neuro* GenoOperators::findNeuro(const Model *m, const NeuroClass *nc)
298{
299        if (!m) return NULL;
300        for (int i = 0; i < m->getNeuroCount(); i++)
301                if (m->getNeuro(i)->getClass() == nc) return m->getNeuro(i);
302        return NULL; //neuron of class 'nc' was not found
303}
304
305int GenoOperators::neuroClassProp(char*& s, NeuroClass *nc, bool also_v1_N_props)
306{
307        int len = (int)strlen(s);
308        int Len = 0, I = -1;
309        if (nc)
310        {
311                Param p = nc->getProperties();
312                for (int i = 0; i<p.getPropCount(); i++)
313                {
314                        const char *n = p.id(i);
315                        int l = (int)strlen(n);
316                        if (len >= l && l>Len && (strncmp(s, n, l) == 0)) { I = 100 + i; Len = l; }
317                        if (also_v1_N_props) //recognize old properties symbols /=!
318                        {
319                                if (strcmp(n, "si") == 0) n = "/"; else
320                                        if (strcmp(n, "in") == 0) n = "="; else
321                                                if (strcmp(n, "fo") == 0) n = "!";
322                                l = (int)strlen(n);
323                                if (len >= l && l > Len && (strncmp(s, n, l) == 0)) { I = 100 + i; Len = l; }
324                        }
325                }
326        }
327        Neuro n;
328        Param p = n.extraProperties();
329        for (int i = 0; i<p.getPropCount(); i++)
330        {
331                const char *n = p.id(i);
332                int l = (int)strlen(n);
333                if (len >= l && l>Len && (strncmp(s, n, l) == 0)) { I = i; Len = l; }
334        }
335        s += Len;
336        return I;
337}
338
339bool GenoOperators::isWS(const char c)
340{
341        return c == ' ' || c == '\n' || c == '\t' || c == '\r';
342}
343
344void GenoOperators::skipWS(char *&s)
345{
346        if (s == NULL)
347                logMessage("GenoOperators", "skipWS", LOG_WARN, "NULL reference!");
348        else
349                while (isWS(*s)) s++;
350}
351
352bool GenoOperators::areAlike(char *g1, char *g2)
353{
354        while (*g1 || *g2)
355        {
356                skipWS(g1);
357                skipWS(g2);
358                if (*g1 != *g2) return false; //when difference
359                if (!*g1 && !*g2) break; //both end
360                g1++;
361                g2++;
362        }
363        return true; //equal
364}
365
366char* GenoOperators::strchrn0(const char *str, char ch)
367{
368        return ch == 0 ? NULL : strchr((char*)str, ch);
369}
370
371bool GenoOperators::canStartNeuroClassName(const char firstchar)
372{
373        return isupper(firstchar) || firstchar == '|' || firstchar == '@' || firstchar == '*';
374}
375
Note: See TracBrowser for help on using the repository browser.