Added python wrapper with pybind11

Author: gramcracker

.vscode/settings.json

@@ -0,0 +1,69 @@
+{
+    "files.associations": {
+        "link.h": "c",
+        "cctype": "c",
+        "clocale": "c",
+        "cmath": "c",
+        "cstdarg": "c",
+        "cstddef": "c",
+        "cstdio": "c",
+        "cstdlib": "c",
+        "cstring": "c",
+        "ctime": "c",
+        "cwchar": "c",
+        "cwctype": "c",
+        "array": "c",
+        "atomic": "c",
+        "strstream": "c",
+        "bit": "c",
+        "*.tcc": "c",
+        "bitset": "c",
+        "chrono": "c",
+        "complex": "c",
+        "condition_variable": "c",
+        "cstdint": "c",
+        "deque": "c",
+        "list": "c",
+        "map": "c",
+        "set": "c",
+        "unordered_map": "c",
+        "unordered_set": "c",
+        "vector": "c",
+        "exception": "c",
+        "algorithm": "c",
+        "functional": "c",
+        "iterator": "c",
+        "memory": "c",
+        "memory_resource": "c",
+        "netfwd": "c",
+        "numeric": "c",
+        "optional": "c",
+        "random": "c",
+        "ratio": "c",
+        "string": "c",
+        "string_view": "c",
+        "system_error": "c",
+        "tuple": "c",
+        "type_traits": "c",
+        "utility": "c",
+        "fstream": "c",
+        "initializer_list": "c",
+        "iomanip": "c",
+        "iosfwd": "c",
+        "iostream": "c",
+        "istream": "c",
+        "limits": "c",
+        "mutex": "c",
+        "new": "c",
+        "ostream": "c",
+        "sstream": "c",
+        "stdexcept": "c",
+        "streambuf": "c",
+        "thread": "c",
+        "cfenv": "c",
+        "cinttypes": "c",
+        "typeindex": "c",
+        "typeinfo": "c",
+        "variant": "c"
+    }
+}

CMakeLists.txt

@@ -1,5 +1,28 @@
 cmake_minimum_required(VERSION 3.10)
+
+project(neuralnetwork)
+
+
+
 file(GLOB_RECURSE libsrc src/*.cpp)
 add_library(neuralnetwork SHARED ${libsrc})
 target_link_libraries(neuralnetwork pthread)
-target_include_directories(neuralnetwork PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_include_directories(neuralnetwork PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+#for using python:
+#(requires installing python3-pybind11)
+find_package(pybind11 REQUIRED)
+
+#use this instead for local pybind11 lib package:
+#(copy pybind11 into python folder)
+# add_subdirectory(python/pybind11)
+# target_include_directories(pyneuralnetwork PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/python/pybind11/include )
+#also comment out this line:
+pybind11_add_module(pyneuralnetwork python/pyInterface.cpp)
+
+target_link_libraries(pyneuralnetwork PUBLIC neuralnetwork)
+set_target_properties(neuralnetwork PROPERTIES
+         LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/lib)
+set_target_properties(pyneuralnetwork PROPERTIES
+         LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/python)
+

README.md

@@ -1,10 +1,9 @@
 # neural_network
-This is my personal project to make a realatively simple neural network framework in C++.
-I created it specifically for experimentation with real time natural language processing 
-and sementic analysis, although it is still a work in progress.
+This is a realatively simple neural network framework in C++. 
 
-I created this because I needed a framework that could be configured in complex and irregular ways for easy experimentation. In order to suit my needs, it has have the following features:
+I created this because I needed a framework that could be configured in complex and irregular ways for easy experimentation. It has have the following features:
 
+* -NEW- now outputs a python wrapper module.
 * Layer by layer syntax. ✓
 * Copy and paste of any portion of the net. ✓
 * Ability for network to build or erase connections. x
@@ -19,15 +18,23 @@ As stated above, this is still a work in progress, and I have yet to implement a
 
 ## Getting Started
 ### Prerequisites
-You will need support for c++ >= 11. This works best with g++ >= 11, and the pthread library.
+-cmake
+-You will need support for c++ >= 11. This works best with g++ >= 11, and the pthread library.
+-To generate the python wrapper you will also need python3-pybind11 or copy the git repo into the local python folder. If using pybind11 locally, make sure to follow directions in the CMakeLists.txt file.
 
-### Installing
+
+### building
 ```
 cd build
 cmake ..
 make
 ```
-then copy the generated neuralnetwork.so file to your project or library path. E.g. /usr/lib/
+### Installing
+```
+chmod +x install.sh
+sudo sh install.sh
+```
+this just copies the generated neuralnetwork.so file to your project to /usr/local/lib/ and the header files to /usr/local/include/neuralnetwork/
 
 ### Usage
 Examples on how to use this library can be found in neural_network/examples/.

include/net.h

@@ -10,6 +10,8 @@
 #include <string>
 #include <tuple>
 #include <functional>
+#include <iostream>
+
 
 
 using namespace std;
@@ -20,6 +22,7 @@ class net //represents a the vector of vectors of neurons
 
   data_operations::random_number_generator rand_generator;
 
+    
     struct Operation
     {
     public:
@@ -106,24 +109,30 @@ class net //represents a the vector of vectors of neurons
     Sequence.at(iteration).push_back(new Operation(this, func, t... ));
   }
 
+
+
   void AddToSequence(int iteration, int layer, int first, int last, void(neuron::*func)());
  // void AddToSequence(int iteration, int layer, void(neuron::*func)());
   //TODO: make main way to run any training and prediction. 
   //(higher level functions like restricted boltzman set up sequence, then call run sequence)
   void RunSequence();
   ofstream& Save(ofstream& file, bool save_neuron_values =false);
   ifstream& Open(ifstream& file);
+
   void SetDesired(vector<double>& desired);   //sets the desired Output of the network for Training
   void SetInput(vector <double>& input);   //sets the input of the network
   void UserInput();
   void SetNeuronTo(int layer, int column, double val);
+
   void SetBias(double val, int _layer, int _neuron);
   void SetBias(double val, int _layer);
   void SetBias(double val);
+  
   void SetWeights(double val, int _layer, int _neuron, int _link);
   void SetWeights(double val, int _layer, int _neuron);
   void SetWeights(double val, int _layer);
   void SetWeights(double val);
+
   void RandomizeWeights(int _layer, int _neuron, int _link);
   void RandomizeWeights(int _layer, int _neuron);
   void RandomizeWeights(int _layer);
@@ -135,24 +144,31 @@ class net //represents a the vector of vectors of neurons
   void FeedForeward( int starting_layer, int ending_layer, int first_neuron, int last_neuron, neuron::ActivationType activation_type = neuron::fast_sigmoid);
   void FeedForeward(vector<double> &input);
   void FeedForeward(neuron::ActivationType activation_type = neuron::fast_sigmoid);
+  
   void Backpropagate();   // backpropagates the error through the network one layer at a time
   void TrainBackpropagation(vector<double>& _desired, vector <double>& _input);
   void TrainBackpropagation(vector<double>& _desired, vector <double>& _input, int _iterations);
   void ContrastDiverge( int starting_layer);   //performs the contrast divergent algorithm between the layer selected and the next layer
+
   void Output();   //displays the Output values of the neurons in every layer
   void Output(string cmd);
   double Output(int row, int column); //returns the output value of the neuron selected
+
   void TrainRestrictedBoltzman(int starting_layer);  //performs the restricted boltzmann machine algorithm between the layer selected and the next layer
   void TrainRestrictedBoltzman(int starting_layer, int iterations);
+
   void OutputToVector(vector<vector<double>>& dataout); //outputs the values of the last layer to a specified vector of vectors
   void OutputToVector(vector<double>& dataout); //outputs the values of the last layer to a specified vector
+
   void AddNeurons(int amount, int layer, string identifying_tag = "");
   void AddNeurons(vector<int> &dimensions, string identifying_tag = "");
+
   void AddFullyConnectedNeurons(int amount, int layer = 0); //adds neurons to specified layer and fully conects them to the network
   net* AppendNet(net* net_from, bool pasteOver);
+  
   void Connect(int layer_from, int column_from, int layer_to, int column_to, float weight);
   void Connect(int layer_from, int column_from, int layer_to, int column_to);
-  void ConnectToNet();
+  
   void SingleConnect();
   void SingleConnect(int layer_from, int layer_to);
   void SingleConnect( string identifying_tag_1, string Identifying_tag_2);
@@ -162,18 +178,17 @@ class net //represents a the vector of vectors of neurons
   void SingleConnectToColumns(string identifying_tag_1, string identifying_tag_2);
   void SingleConnectFromRows(int layer_from, int layer_to);
   void SingleConnectFromColumns(int layer_from, int layer_to);
+
   void FullyConnect();  //fully connects all layers in the net(does not clear out previous links)
   void FullyConnect(int layer_from, int layer_to);  //fully connects a specific portion of the network
   void FullyConnect(int layer_from, int lfstart, int lfend, int layer_to, int ltstart, int ltend);
   void FullyConnect( net* net_to, int layer_from, int layer_to);   //fully connects a specific layer of a net to a specific layer in a seperate net
+
   void CleanAfterBuild();//cleans up excess memory used for building network
+
   int get_size();// returns size of the net
   int get_size(int i);  //returns the size of the layer
 
-
-
-
-
   protected:
       // if layers are filled manually, destructor
       //will cause destructor to delete objects twice
@@ -183,9 +198,9 @@ class net //represents a the vector of vectors of neurons
   private:
 
 
-
 };
 
 
 
+
 #endif

install.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+lib=lib/libneuralnetwork.so
+include=include
+
+if test -f "$lib"
+
+then
+    cp "$lib" /usr/local/lib/
+    cp -a "$include"/. /usr/local/include/neuralnetwork/
+else
+    echo "library not generated, must run cmake then make first."
+fi

lib/libneuralnetwork.so

@@ -0,0 +1,3 @@
+*
+!.gitignore
+!pyInterface.cpp

python/.gitignore

@@ -0,0 +1,16 @@
+#include <net.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <iostream>
+#include <vector>
+#include <string>
+
+
+using namespace::std;
+namespace py = pybind11;
+PYBIND11_MODULE(pyneuralnetwork, m) {
+    py::class_<net>(m, "net")
+    .def(py::init<>())
+    .def("addNeurons", py::overload_cast<int , int , std::string >(&net::AddNeurons))
+    .def("size", py::overload_cast<>(&net::get_size));
+}

python/pyInterface.cpp

@@ -8,6 +8,9 @@
 #include <tuple>
 #include <string>
 #include <unordered_set>
+
+
+
 using namespace std;
 
 /**
@@ -16,7 +19,6 @@ using namespace std;
 net::net(){cout<<"new net"<<endl;};
 
 
-
 /**
  * @brief      Constructs the net object.
  *
@@ -754,7 +756,6 @@ void net::AddNeurons(vector<int> &dimensions, string identifying_tag){
 
 
 
-
 net* net::AppendNet(net* net_from, bool pasteOver)
 {
     if(pasteOver){