<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>README.md - +/GENN @ master</title>
<meta name="description" content="README.md in +/GENN at master.">
<meta property="og:title" content="README.md - +/GENN @ master">
<meta property="og:description" content="README.md in +/GENN at master.">
<meta property="og:type" content="website">
<meta property="og:site_name" content="git.julia.blue">
<link rel="stylesheet" href="/css/style.css?v=62">
<script type="module" src="/js/main.js?v=62"></script>
</head>
<body>
<main data-ref="master" data-tip="369529e46abbf616f6d2000f5bea6f119a0f6127">
<noscript>
  <div class="callout">
    <p>
      hey! this is a static git repo viewer. commit diffs, file history,
      older commits and other revisions won't load without javascript.
    </p>
    <p>
      you are still able to view source files on branch/tag tips,
      but the experience is degraded.
    </p>
  </div>
</noscript>
<header class="repo"><div>
<h1>+/GENN</h1>
<p class="desc">genetically evolving neural networks</p>
</div>
<pre class="clone">git clone https://git.julia.blue/+/GENN</pre>
</header>
<p class="snapshot-commit"><span class="commit-author">Joseph Ryan</span><span class="commit-message" data-commit="369529e46abbf616f6d2000f5bea6f119a0f6127">Update link</span><span class="snapshot-sha sha" data-commit="369529e46abbf616f6d2000f5bea6f119a0f6127">369529e</span><time datetime="2017-04-17T21:48:28-04:00" title="2017-04-17 21:48:28 -0400">2017-04-17</time></p>
<header class="topbar"><details class="switcher"><summary>master</summary><div class="menu"><strong>branches</strong><a href="/%2B/GENN/ref/imdone-todo-updates/">imdone-todo-updates</a><a class="current" href="/%2B/GENN/ref/master/">master</a><strong>tags</strong><a href="/%2B/GENN/ref/v0.1/">v0.1</a><a href="/%2B/GENN/ref/v0.2/">v0.2</a><a href="/%2B/GENN/ref/v1.0/">v1.0</a><a class="all" href="/%2B/GENN/refs">all refs →</a></div></details><nav class="crumbs"><a href="/%2B/GENN/">GENN</a> / <span class="cur">README.md</span></nav>
<span class="view-stats"><span>2.6 KiB</span><span>62 lines</span></span><span class="actions"><a class="raw" href="/%2B/GENN/raw/28000cfebd8aea67b0aafd2810bc7945c176a5e5/README.md">raw</a></span></header>
<div class="markdown-view"><input type="radio" name="markdown-view" id="markdown-rendered" checked><label for="markdown-rendered">rendered</label><input type="radio" name="markdown-view" id="markdown-code"><label for="markdown-code">code</label><section class="readme rendered"><h1><em>Genetically Evolving Neural Networks</em></h1>
<h2><strong>About</strong></h2>
<p>NeuroEvolution of Augmenting Topologies is a genetic algorithm developed by Kenneth O. Stanley for evolving neural networks' weights and topologies. This project is a modified implementation of that algorithm for use with Recurrent Neural Networks. The intended purpose is producing more efficient solutions to continuous input simulations such as control theory problems and real time video games. While GENN <em>can</em> still solve traditional classification problems, it would be easier and more efficient to use a different machine learning solution.</p>
<p><a href="http://nn.cs.utexas.edu/?neat">More info</a></p>
<h2><strong>Adding simulations</strong></h2>
<p>Running GENN on your own problems is easy:</p>
<ol>
<li>Write a port of your simulation in C++11</li>
<li>OPTIONAL: write a visualization of your simulation using the tigr graphics library, which is included with the source.</li>
<li>Write the required framework (just 2 functions) for your simulation to interface with the NEAT algorithm</li>
</ol>
<p>Here is some pseudo-code for creating a simulation (full source of Xor and Pole Balance in /examples/)</p>
<p><code>Sim.cpp</code></p>
<pre class="language-cpp"><a-c>// The constructor must create a controller object with two arguments,</a-c>
<a-c>// the number of outputs from and inputs to your simulation respectively</a-c>
<a-t>Sim</a-t>::<a-f>Sim</a-f>() {
    <a-v>controller</a-v> <a-o>=</a-o> <a-k>new</a-k> <a-t>NEAT</a-t>(<a-n>3</a-n>, <a-n>1</a-n>);
}

<a-c>// GENN will call this function to test potential solutions</a-c>
<a-t>void</a-t> <a-t>Sim</a-t>::<a-f>evaluate</a-f>(<a-t>Genome</a-t> <a-o>&amp;</a-o><a-v>g</a-v>) {
    <a-t>Network</a-t> <a-f>n</a-f>(<a-t>g</a-t>);
    <a-t>double</a-t> <a-v>inputs</a-v>[<a-v>numberOfInputs</a-v>];
    <a-t>double</a-t> <a-v>outputs</a-v>[<a-v>numberOfOutputs</a-v>];
    <a-k>while</a-k>(<a-v>simulationIsRunning</a-v>){
        <a-c>// Pull values from the state of your simulation</a-c>
        <a-f>updateInputs</a-f>();
        <a-c>// Run the data through the neural network and pushes the results to &quot;outputs[]&quot;</a-c>
        <a-v>n</a-v>.<a-f>propagate</a-f>(<a-v>inputs</a-v>,<a-v>outputs</a-v>);
        <a-c>// Run the logic of your simulation to advance by a timeStep. For non-continuous problems just run this a few times to give the network time to propagate</a-c>
        <a-f>updateSimulation</a-f>(<a-v>outputs</a-v>);
    }
    <a-v>g</a-v>.<a-pr>fitness</a-pr><a-o>=</a-o><a-n>1</a-n><a-o>-</a-o><a-v>error</a-v>; <a-c>// Fitness is a double with higher values corresponding to better performance. The efficacy of the algorithm relies on an accurate fitness function</a-c>
}

<a-c>// Same as evaluate() but used for viewing results instead of testing</a-c>
<a-c>// You don&#39;t need to evaluate the fitness, and you can add some sort of display to see the solution at work</a-c>
<a-t>void</a-t> <a-t>Sim</a-t>::<a-f>view</a-f>(<a-t>Network</a-t> <a-v>n</a-v>) {}</pre>
<p><code>main.cpp</code></p>
<pre class="language-cpp"><a-k>#include</a-k> <a-s>&quot;Sim.h&quot;</a-s>

<a-t>int</a-t> <a-f>main</a-f>() {
    <a-t>Sim</a-t> <a-v>test</a-v>;

    <a-c>// This will train a solution for n epochs</a-c>
    <a-v>test</a-v>.<a-f>run</a-f>(<a-v>n</a-v>);

    <a-c>// This will view a saved solution</a-c>
    <a-c>// The default location for them is /bin/log.txt</a-c>
    <a-t>Genome</a-t> <a-v>g</a-v>(<a-f>Genome</a-f>(<a-s>&quot;base64 encoded string here&quot;</a-s>);
    <a-v>test</a-v>.<a-f>view</a-f>(<a-f>Network</a-f>(<a-v>g</a-v>));
}</pre>
</section><div class="code-panel"><pre class="code src language-markdown"><span class="code-line"><a class="ln" id="L1" href="#L1">1</a><span class="code-text"><a-p>#</a-p> <a-tt>*Genetically Evolving Neural Networks*</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L2" href="#L2">2</a><span class="code-text"><a-p>##</a-p> <a-tt>**About**</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L3" href="#L3">3</a><span class="code-text">NeuroEvolution of Augmenting Topologies is a genetic algorithm developed by Kenneth O. Stanley for evolving neural networks&#39; weights and topologies. This project is a modified implementation of that algorithm for use with Recurrent Neural Networks. The intended purpose is producing more efficient solutions to continuous input simulations such as control theory problems and real time video games. While GENN *can* still solve traditional classification problems, it would be easier and more efficient to use a different machine learning solution.</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L4" href="#L4">4</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L5" href="#L5">5</a><span class="code-text">[More info](http://nn.cs.utexas.edu/?neat)</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L6" href="#L6">6</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L7" href="#L7">7</a><span class="code-text"><a-p>##</a-p> <a-tt>**Adding simulations**</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L8" href="#L8">8</a><span class="code-text">Running GENN on your own problems is easy:</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L9" href="#L9">9</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L10" href="#L10">10</a><span class="code-text"><a-p>1. </a-p>Write a port of your simulation in C++11</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L11" href="#L11">11</a><span class="code-text"><a-p>2. </a-p>OPTIONAL: write a visualization of your simulation using the tigr graphics library, which is included with the source.</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L12" href="#L12">12</a><span class="code-text"><a-p>3. </a-p>Write the required framework (just 2 functions) for your simulation to interface with the NEAT algorithm</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L13" href="#L13">13</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L14" href="#L14">14</a><span class="code-text"><a-p>Here is some pseudo-code for creating a simulation (full source of Xor and Pole Balance in /examples/)</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L15" href="#L15">15</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L16" href="#L16">16</a><span class="code-text"><a-p>`Sim.cpp`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L17" href="#L17">17</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L18" href="#L18">18</a><span class="code-text"><a-p>```</a-p><a-tl>c++</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L19" href="#L19">19</a><span class="code-text"><a-p>// The constructor must create a controller object with two arguments,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L20" href="#L20">20</a><span class="code-text"><a-p>// the number of outputs from and inputs to your simulation respectively</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L21" href="#L21">21</a><span class="code-text"><a-p>Sim::Sim() {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L22" href="#L22">22</a><span class="code-text"><a-p>    controller = new NEAT(3, 1);</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L23" href="#L23">23</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L24" href="#L24">24</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L25" href="#L25">25</a><span class="code-text"><a-p>// GENN will call this function to test potential solutions</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L26" href="#L26">26</a><span class="code-text"><a-p>void Sim::evaluate(Genome &amp;g) {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L27" href="#L27">27</a><span class="code-text"><a-p>    Network n(g);</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L28" href="#L28">28</a><span class="code-text"><a-p>    double inputs[numberOfInputs];</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L29" href="#L29">29</a><span class="code-text"><a-p>    double outputs[numberOfOutputs];</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L30" href="#L30">30</a><span class="code-text"><a-p>    while(simulationIsRunning){</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L31" href="#L31">31</a><span class="code-text"><a-p>        // Pull values from the state of your simulation</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L32" href="#L32">32</a><span class="code-text"><a-p>        updateInputs();</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L33" href="#L33">33</a><span class="code-text"><a-p>        // Run the data through the neural network and pushes the results to &quot;outputs[]&quot;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L34" href="#L34">34</a><span class="code-text"><a-p>        n.propagate(inputs,outputs);</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L35" href="#L35">35</a><span class="code-text"><a-p>        // Run the logic of your simulation to advance by a timeStep. For non-continuous problems just run this a few times to give the network time to propagate</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L36" href="#L36">36</a><span class="code-text"><a-p>        updateSimulation(outputs);</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L37" href="#L37">37</a><span class="code-text"><a-p>    }</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L38" href="#L38">38</a><span class="code-text"><a-p>    g.fitness=1-error; // Fitness is a double with higher values corresponding to better performance. The efficacy of the algorithm relies on an accurate fitness function</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L39" href="#L39">39</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L40" href="#L40">40</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L41" href="#L41">41</a><span class="code-text"><a-p>// Same as evaluate() but used for viewing results instead of testing</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L42" href="#L42">42</a><span class="code-text"><a-p>// You don&#39;t need to evaluate the fitness, and you can add some sort of display to see the solution at work</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L43" href="#L43">43</a><span class="code-text"><a-p>void Sim::view(Network n) {}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L44" href="#L44">44</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L45" href="#L45">45</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L46" href="#L46">46</a><span class="code-text"><a-p>`main.cpp`</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L47" href="#L47">47</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L48" href="#L48">48</a><span class="code-text"><a-p>```</a-p><a-tl>c++</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L49" href="#L49">49</a><span class="code-text"><a-p>#include &quot;Sim.h&quot;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L50" href="#L50">50</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L51" href="#L51">51</a><span class="code-text"><a-p>int main() {</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L52" href="#L52">52</a><span class="code-text"><a-p>    Sim test;</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L53" href="#L53">53</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L54" href="#L54">54</a><span class="code-text"><a-p>    // This will train a solution for n epochs</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L55" href="#L55">55</a><span class="code-text"><a-p>    test.run(n);</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L56" href="#L56">56</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L57" href="#L57">57</a><span class="code-text"><a-p>    // This will view a saved solution</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L58" href="#L58">58</a><span class="code-text"><a-p>    // The default location for them is /bin/log.txt</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L59" href="#L59">59</a><span class="code-text"><a-p>    Genome g(Genome(&quot;base64 encoded string here&quot;);</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L60" href="#L60">60</a><span class="code-text"><a-p>    test.view(Network(g));</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L61" href="#L61">61</a><span class="code-text"><a-p>}</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L62" href="#L62">62</a><span class="code-text"><a-p>```</a-p></span></span></pre></div></div>
</main>
</body>
</html>
