Empty field first

Author: mikolasan

graphics/neurons/data_processor.h

@@ -1,11 +1,11 @@
 #ifndef DATA_PROCESSOR_H
 #define DATA_PROCESSOR_H
 
-#include <bx/math.h>
+#include <vector>
 
 
 class DataProcessor {
-  virtual bx::Vec3 get_area_size() const = 0;
+  virtual std::vector<size_t> get_area_size() const = 0;
 };
 
 

graphics/neurons/mnist_data_processor.cpp

@@ -23,7 +23,7 @@ bgfx::TextureHandle create_mnist_texture(const uint8_t* pixels) {
     rgba[i * 4 + 3] = 255;
   }
 
-  const bgfx::Memory* mem = bgfx::copy(rgba.data(), rgba.size());
+  const bgfx::Memory* mem = bgfx::copy(rgba.data(), static_cast<uint32_t>(rgba.size()));
   return bgfx::createTexture2D(width, height, false, 1, bgfx::TextureFormat::RGBA8, 0, mem);
 }
 
@@ -37,8 +37,8 @@ size_t MnistDataProcessor::get_input_size() const {
   return input_size;
 }
 
-bx::Vec3 MnistDataProcessor::get_area_size() const {
-  return { width, height, 1.0f };
+std::vector<size_t> MnistDataProcessor::get_area_size() const {
+  return { width, height, 1 };
 }
 
 size_t MnistDataProcessor::get_max_id() const {
@@ -79,16 +79,16 @@ std::vector<uint8_t> MnistDataProcessor::convert_current_to_inputs() {
   return inputs;
 }
 
-Network::NeuronLayer MnistDataProcessor::prepare_neurons() const {
-  Network::NeuronLayer neurons(input_size);
-  bx::Vec3 area_size = get_area_size();
+NeuronLayer MnistDataProcessor::prepare_neurons() const {
+  NeuronLayer neurons(input_size);
+  const auto 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,
+      float(i % area_size[0]),
+      float(i / area_size[0]),
       0.0f };
     neurons[i]->render = std::make_shared<NeuronRenderStrategy>(ctx);
   }

graphics/neurons/mnist_data_processor.h

@@ -12,7 +12,7 @@
 
 #include "data_processor.h"
 #include "neuron.hpp"
-#include "network.hpp"
+#include "network.h"
 
 const size_t input_size = 784;
 const uint32_t width = 28, height = 28;
@@ -33,15 +33,15 @@ class MnistDataProcessor : public DataProcessor {
   void init();
 
   size_t get_input_size() const;
-  bx::Vec3 get_area_size() const override;
+  std::vector<size_t> get_area_size() const override;
   size_t get_max_id() const;
   size_t get_current_id() const;
   uint8_t get_current_label() const;
   void set_current_id(size_t id);
   bgfx::TextureHandle create_currnet_texture();
   std::vector<uint8_t> convert_current_to_inputs();
 
-  Network::NeuronLayer prepare_neurons() const;
+  NeuronLayer prepare_neurons() const;
 
 };
 

graphics/neurons/network.cpp

@@ -1,19 +1,58 @@
 #include <iostream>
 
 #include "network.h"
+#include "render/neuron_render.hpp"
+#include "render/network_render.h"
 
-void Network::addLayer(const NeuronLayer&& layer) {
+
+void Network::addLayer(const NeuronLayer&& layer, const std::vector<size_t>& area_size) {
     layers.push_back(layer);
-    neurons.assign(layer.begin(), layer.end());
+
+    uint32_t last_id = neurons.back()->idx;
+    for (auto it = layer.begin(); it != layer.end(); ++it)
+    {
+        (*it)->idx = ++last_id;
+        neurons.emplace_back(std::move(*it));
+    }
+
+    // neurons.assign(layer.begin(), layer.end());
     if (render && std::dynamic_pointer_cast<NetworkRenderStrategy>(render) != nullptr) {
-        std::dynamic_pointer_cast<NetworkRenderStrategy>(render)->addLayer(layer);
+        std::dynamic_pointer_cast<NetworkRenderStrategy>(render)->addLayer(layer, area_size);
     }
 }
 
-// void setSize(int N) {
-//     neurons.resize(N);
-//     // synapses.resize(N, std::vector<Synapse>(N));
-// }
+void Network::addNeuron(const std::vector<size_t>& pos, const NeuronLayer& connected_to) {
+    uint32_t layer = pos[2];
+    if (layer >= layers.size()) {
+        std::cerr << "wrong layer position\n";
+        return;
+    }
+
+    std::shared_ptr<Neuron> neuron = std::make_shared<Neuron>();
+    neuron->idx = create_id(nullptr);
+    auto ctx = std::make_shared<NeuronVisualContext>(neuron);
+    ctx->position = { float(pos[0]), float(pos[1]), float(pos[2]) };
+    neuron->render = std::make_shared<NeuronRenderStrategy>(ctx);
+
+    layers[layer].push_back(neuron);
+    neurons.push_back(neuron);
+}
+
+void Network::addConnection(const std::shared_ptr<Neuron>& n1, const std::shared_ptr<Neuron>& n2) {
+    synapses.emplace(idsToLocation(n1->idx, n2->idx), std::make_shared<Synapse>());
+}
+
+std::pair<uint32_t, uint32_t> Network::locationToIds(uint64_t loc) const {
+    uint32_t pre_idx = loc & 0xffff;
+    uint32_t post_idx = (loc >> 8) & 0xffff;
+    return {pre_idx, post_idx};
+}
+
+uint64_t Network::idsToLocation(uint32_t pre, uint32_t post) const {
+    uint64_t loc = 0;
+    loc = pre | (post << 8);
+    return loc;
+}
 
 std::vector<float> Network::get_current_voltage_state() const {
     std::vector<float> state(neurons.size(), 0.0);
@@ -37,16 +76,15 @@ void Network::step(std::vector<uint8_t> inputs) {
 
     // Synaptic input
     for (auto& [loc, syn] : synapses) {
-        uint32_t pre_idx = loc & 0xffff;
-        uint32_t post_idx = (loc >> 8) & 0xffff;
+        auto [pre_idx, post_idx] = locationToIds(loc);
 
-        syn.update_pre(dt);
-        syn.update_post(dt);
+        syn->update_pre(dt);
+        syn->update_post(dt);
 
         // STDP
         if (neurons[pre_idx]->spiked) {
-            syn.on_pre_spike();
-            dv[post_idx] += syn.weight;
+            syn->on_pre_spike();
+            dv[post_idx] += syn->weight;
         }
     }
 
@@ -56,10 +94,9 @@ void Network::step(std::vector<uint8_t> inputs) {
 
     // 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();
+        auto [pre_idx, post_idx] = locationToIds(loc);
+        syn->apply_stdp(neurons[pre_idx]->spiked, neurons[post_idx]->spiked);
+        if (neurons[post_idx]->spiked) syn->on_post_spike();
     }
 
     time += dt;
@@ -85,4 +122,8 @@ void Network::update(float dt) {
 
 void Network::destroy() const {
     if (render) render->destroy();
+}
+
+uint32_t Network::create_id(std::shared_ptr<Neuron> neuron) const {
+    return neurons.size();
 }

graphics/neurons/network.h

@@ -8,31 +8,42 @@
 #include "neuron.hpp"
 #include "synapse.hpp"
 #include "render_strategy.h"
-#include "render/network_render.h"
 
 using NeuronLayer = std::vector<std::shared_ptr<Neuron>>;
+using Neocortex = std::vector<NeuronLayer>; // lol
+using FlatNeuronStorage = std::vector<std::shared_ptr<Neuron>>;
+using Location = uint64_t;
+using SynapsesMap = std::unordered_map<Location, std::shared_ptr<Synapse>>;
 
 struct Network {
-    std::vector<std::shared_ptr<Neuron>> neurons;
+    FlatNeuronStorage neurons;
     std::vector<NeuronLayer> layers;
-
-    using Location = uint64_t;
-    std::unordered_map<Location, Synapse> synapses;
+    SynapsesMap 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);
+    void addLayer(const NeuronLayer&& layer, const std::vector<size_t>& area_size);
+    void addNeuron(const std::vector<size_t>& pos, const NeuronLayer& connected_to);
+    void addConnection(const std::shared_ptr<Neuron>& n1,
+        const std::shared_ptr<Neuron>& n2);
+
+    std::pair<uint32_t, uint32_t> locationToIds(uint64_t loc) const;
+    uint64_t idsToLocation(uint32_t pre, uint32_t post) const;
+    
     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;
+
+    uint32_t create_id(std::shared_ptr<Neuron> neuron) const;
 };
 
 #endif

graphics/neurons/neurons_gui.cpp

@@ -16,7 +16,7 @@
 #include "imgui/bgfx_imgui.h"
 
 #include "neuron.hpp"
-#include "network.hpp"
+#include "network.h"
 #include "render/neuron_render.hpp"
 #include "render/network_render.h"
 #include "simulation_clock.hpp"
@@ -83,8 +83,11 @@ namespace
 			net.render = std::make_shared<NetworkRenderStrategy>(ctx);
 
 
-			net.addLayer(data.prepare_neurons());
-			// bx::Vec3 area_size = data.get_area_size();
+			bool loadReceptors = false;
+			if (loadReceptors) {
+				const auto area_size = data.get_area_size();
+				net.addLayer(data.prepare_neurons(), area_size);
+			}
 
 			// for (size_t i = 0; i < net.neurons.size(); ++i) {
 			// 	auto ctx2 = std::make_shared<NeuronVisualContext>(net.neurons[i]);

graphics/neurons/render/network_render.cpp

@@ -81,7 +81,12 @@ void NetworkRenderStrategy::init() {
     m_program = loadProgram("vs_instancing", "fs_instancing");
 }
 
-void NetworkRenderStrategy::addLayer(const NeuronLayer& layer) {}
+void NetworkRenderStrategy::addLayer(const NeuronLayer& layer, const std::vector<size_t>& area_size) {
+    area_size_x = area_size[0];
+    area_size_y = area_size[1];
+    area_size_z = area_size[2];
+
+}
 
 void NetworkRenderStrategy::update(float dt) {
     if (ImGui::IsKeyPressed(ImGuiKey_W))
@@ -98,19 +103,23 @@ void NetworkRenderStrategy::update(float dt) {
         selected_x = std::max(0, selected_z - 1);
     if (ImGui::IsKeyPressed(ImGuiKey_F))
         selected_x = std::min(area_size_z - 1, selected_z + 1);
-    
-    // to total number of instances to draw
+
+        // to total number of instances to draw
     uint32_t totalCubes = ctx->net.neurons.size();
 
-    // figure out how big of a buffer is available
-    drawnCubes = bgfx::getAvailInstanceDataBuffer(totalCubes, instanceStride);
+    if (totalCubes > 0) {
+        // figure out how big of a buffer is available
+        drawnCubes = bgfx::getAvailInstanceDataBuffer(totalCubes, instanceStride);
 
-    // save how many we couldn't draw due to buffer room so we can display it
-    m_lastFrameMissing = totalCubes - drawnCubes;
+        // save how many we couldn't draw due to buffer room so we can display it
+        m_lastFrameMissing = totalCubes - drawnCubes;
+    } else {
+        drawnCubes = 0;
+        m_lastFrameMissing = 0;
+    }
 }
 
-void NetworkRenderStrategy::draw(float time) const {
-
+void NetworkRenderStrategy::drawNeurons(float time) const {
     bgfx::InstanceDataBuffer idb;
     bgfx::allocInstanceDataBuffer(&idb, drawnCubes, instanceStride);
 
@@ -176,7 +185,14 @@ void NetworkRenderStrategy::draw(float time) const {
 
     // Submit primitive for rendering to view 0.
     bgfx::submit(0, m_program);
+}
 
+void NetworkRenderStrategy::drawSelection(float time) const {
+
+    const float offset = 3.0f;
+    const float start_x = - area_size_x * offset / 2.0f;
+    const float start_y = - area_size_y * offset / 2.0f;
+    const float start_z = - area_size_z * offset / 2.0f;
 
     // Compute selection position
     float sel_x = start_x + selected_x * offset;
@@ -197,7 +213,14 @@ void NetworkRenderStrategy::draw(float time) const {
     bgfx::setIndexBuffer(m_selection_ibh);
     bgfx::setState(BGFX_STATE_DEFAULT | BGFX_STATE_PT_LINES);  // Use wireframe cube
     bgfx::submit(0, m_selection_program);
+}
+
+void NetworkRenderStrategy::draw(float time) const {
+    if (drawnCubes > 0) {
+        drawNeurons(time);
+    }
 
+    drawSelection(time);
 }
 
 void NetworkRenderStrategy::destroy() {

graphics/neurons/render/network_render.h

@@ -32,11 +32,14 @@ struct NetworkRenderStrategy : RenderStrategy {
     // }
 
     void init() override;
-    void addLayer(const NeuronLayer& layer);
+    void addLayer(const NeuronLayer& layer, const std::vector<size_t>& area_size);
     void update(float dt) override;
     void draw(float time) const override;
     void destroy() override;
 
+    void drawNeurons(float time) const;
+    void drawSelection(float time) const;
+
     bgfx::VertexBufferHandle m_vbh;
     bgfx::IndexBufferHandle  m_ibh;