New cpp files

Author: mikolasan

graphics/CMakeLists.txt

@@ -189,7 +189,7 @@ if (MSVC)
 endif ()
 
 add_executable(neurons_cli
-    neurons/network.hpp
+    neurons/network.cpp
     neurons/neurons_cli.cpp
 )
 
@@ -225,10 +225,10 @@ add_executable(neurons_gui
     thirdparty/imgui/backends/imgui_impl_opengl3.cpp
     thirdparty/imgui/backends/imgui_impl_sdl2.cpp
     neurons/renderer.cpp
-    neurons/network.hpp
-    neurons/render/neuron_render.hpp
+    neurons/network.cpp
+    neurons/mnist_data_processor.cpp
     neurons/render/neuron_render.cpp
-    neurons/render/network_render.hpp
+    neurons/render/network_render.cpp
     # neurons/camera.cpp
     # neurons/mouse.cpp
     # neurons/settings.cpp

graphics/neurons/mnist_data_processor.cpp

@@ -1,15 +1,6 @@
 #include "mnist_data_processor.h"
 #include "render/neuron_render.hpp"
 
-
-const size_t input_size = 784;
-const uint32_t width = 28, height = 28;
-
-struct MnistImage {
-  uint8_t label;
-  uint8_t pixels[input_size];
-};
-
 std::vector<MnistImage> load_mnist_bin(const std::string& path) {
   std::ifstream in(path, std::ios::binary);
   std::vector<MnistImage> images;
@@ -89,15 +80,18 @@ std::vector<uint8_t> MnistDataProcessor::convert_current_to_inputs() {
 }
 
 Network::NeuronLayer MnistDataProcessor::prepare_neurons() const {
-  std::vector<Neuron> neurons(input_size);
+  Network::NeuronLayer neurons(input_size);
   bx::Vec3 area_size = get_area_size();
 
   for (size_t i = 0; i < input_size; ++i) {
+    neurons[i] = std::make_shared<Neuron>();
     auto ctx = std::make_shared<NeuronVisualContext>(neurons[i]);
     ctx->position = {
       float(i % int32_t(area_size.x)),
       i / area_size.x,
       0.0f };
-    neurons[i].render = std::make_shared<NeuronRenderStrategy>(ctx);
+    neurons[i]->render = std::make_shared<NeuronRenderStrategy>(ctx);
   }
+
+  return neurons;
 }

graphics/neurons/mnist_data_processor.h

@@ -14,7 +14,13 @@
 #include "neuron.hpp"
 #include "network.hpp"
 
-struct MnistImage;
+const size_t input_size = 784;
+const uint32_t width = 28, height = 28;
+
+struct MnistImage {
+  uint8_t label;
+  uint8_t pixels[input_size];
+};
 
 class MnistDataProcessor : public DataProcessor {
 private:

graphics/neurons/network.cpp

@@ -0,0 +1,88 @@
+#include <iostream>
+
+#include "network.h"
+
+void Network::addLayer(const NeuronLayer&& layer) {
+    layers.push_back(layer);
+    neurons.assign(layer.begin(), layer.end());
+    if (render && std::dynamic_pointer_cast<NetworkRenderStrategy>(render) != nullptr) {
+        std::dynamic_pointer_cast<NetworkRenderStrategy>(render)->addLayer(layer);
+    }
+}
+
+// void setSize(int N) {
+//     neurons.resize(N);
+//     // synapses.resize(N, std::vector<Synapse>(N));
+// }
+
+std::vector<float> Network::get_current_voltage_state() const {
+    std::vector<float> state(neurons.size(), 0.0);
+    for (size_t i = 0; i < neurons.size(); ++i) {
+        state[i] = neurons[i]->v;
+    }
+    return state;
+}
+
+void Network::step(std::vector<uint8_t> inputs) {
+    std::cout << "step (" << time << ")\n";
+    
+    for (size_t i = 0; i < inputs.size(); i++)
+    {
+        if (inputs[i] > 0) {
+            neurons[i]->v += 1.5f * (inputs[i] / 255.0f) * 0.2f;  // inject current to neuron 0
+        }
+    }
+    
+    std::vector<float> dv(neurons.size(), 0.0f);
+
+    // Synaptic input
+    for (auto& [loc, syn] : synapses) {
+        uint32_t pre_idx = loc & 0xffff;
+        uint32_t post_idx = (loc >> 8) & 0xffff;
+        
+        syn.update_pre(dt);
+        syn.update_post(dt);
+
+        // STDP
+        if (neurons[pre_idx]->spiked) {
+            syn.on_pre_spike();
+            dv[post_idx] += syn.weight;
+        }
+    }
+
+    // Neuron updates
+    for (size_t i = 0; i < neurons.size(); ++i)
+        neurons[i]->update(dv[i], dt, time);
+
+    // STDP
+    for (auto& [loc, syn] : synapses) {
+        uint32_t pre_idx = loc & 0xffff;
+        uint32_t post_idx = (loc >> 8) & 0xffff;
+        syn.apply_stdp(neurons[pre_idx]->spiked, neurons[post_idx]->spiked);
+        if (neurons[post_idx]->spiked) syn.on_post_spike();
+    }
+
+    time += dt;
+}
+
+void Network::init() {
+    if (render) render->init();
+}
+
+void Network::draw(float time) const {
+    if (render) render->draw(time);
+}
+
+// void draw() const {
+//     for (auto& n : neurons) {
+//         n.draw();
+//     }
+// }
+
+void Network::update(float dt) {
+    if (render) render->update(dt);
+}
+
+void Network::destroy() const {
+    if (render) render->destroy();
+}

graphics/neurons/network.h

@@ -0,0 +1,38 @@
+#ifndef NETWORK_H
+#define NETWORK_H
+
+#include <memory>
+#include <vector>
+#include <unordered_map>
+
+#include "neuron.hpp"
+#include "synapse.hpp"
+#include "render_strategy.h"
+#include "render/network_render.h"
+
+using NeuronLayer = std::vector<std::shared_ptr<Neuron>>;
+
+struct Network {
+    std::vector<std::shared_ptr<Neuron>> neurons;
+    std::vector<NeuronLayer> layers;
+
+    using Location = uint64_t;
+    std::unordered_map<Location, Synapse> synapses;
+    // std::vector<std::vector<Synapse>> synapses;
+    float dt = 1.0f;
+    float time = 0.0f;
+
+    std::shared_ptr<RenderStrategy> render;
+
+    explicit Network() = default;
+
+    void addLayer(const NeuronLayer&& layer);
+    std::vector<float> get_current_voltage_state() const;
+    void step(std::vector<uint8_t> inputs);
+    void init();
+    void draw(float time) const;
+    void update(float dt);
+    void destroy() const;
+};
+
+#endif

graphics/neurons/network.hpp

@@ -18,7 +18,7 @@
 #include "neuron.hpp"
 #include "network.hpp"
 #include "render/neuron_render.hpp"
-#include "render/network_render.hpp"
+#include "render/network_render.h"
 #include "simulation_clock.hpp"
 #include "mnist_data_processor.h"
 
@@ -153,11 +153,11 @@ namespace
 				showExampleDialog(this);
 
 				ImGui::SetNextWindowPos(
-					ImVec2(m_width - m_width / 5.0f - 10.0f, 10.0f)
+					ImVec2(m_width - m_width / 3.0f - 10.0f, 10.0f)
 					, ImGuiCond_FirstUseEver
 				);
 				ImGui::SetNextWindowSize(
-					ImVec2(m_width / 5.0f, m_height / 2.0f)
+					ImVec2(m_width / 3.0f, m_height / 1.2f)
 					, ImGuiCond_FirstUseEver
 				);
 				ImGui::Begin("Settings"