Finished Module. Next is the demo.

githubhy · githubhy · commit e88a70fdce8f · 2024-06-30T10:07:13.000+08:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -7,5 +7,16 @@ project(Micrograd)
 set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 
-# Add the executable
-add_executable(Micrograd test_Value.cpp)
+# Define an option to switch between main and test
+option(USE_TEST "Use the test source file" OFF)
+
+# Conditionally add the source file based on the option
+if(USE_TEST)
+    message(STATUS "Building with test files")
+    add_executable(Micrograd test_Value.cpp)
+else()
+    add_executable(Micrograd main.cpp)
+endif()
+
+# Include directories
+target_include_directories(Micrograd PRIVATE .)
diff --git a/Module.h b/Module.h
@@ -0,0 +1,139 @@
+#ifndef MODULE_H
+#define MODULE_H
+
+#include <vector>
+#include <variant>
+#include <memory>
+#include <random>
+#include <iostream>
+#include "Value.h"
+
+class Module {
+public:
+    virtual void zero_grad() {
+        for (auto& p : parameters()) {
+            p->grad = 0;
+        }
+    }
+
+    virtual std::vector<std::shared_ptr<Value>> parameters() {
+        return {};
+    }
+};
+
+class Neuron : public Module {
+public:
+    std::vector<std::shared_ptr<Value>> w;
+    std::shared_ptr<Value> b;
+    bool nonlin;
+
+    Neuron(int nin, bool nonlin = true) 
+        : b(std::make_shared<Value>(0)), nonlin(nonlin) {
+        std::uniform_real_distribution<double> unif(-1, 1);
+        std::default_random_engine re;
+        for (int i = 0; i < nin; ++i) {
+            w.push_back(std::make_shared<Value>(unif(re)));
+        }
+    }
+
+    std::shared_ptr<Value> operator()(const std::vector<std::shared_ptr<Value>>& x) {
+        auto act = b;
+        for (size_t i = 0; i < w.size(); ++i) {
+            act = act + (w[i] * x[i]);
+        }
+        return nonlin ? act->relu() : act;
+    }
+
+    std::vector<std::shared_ptr<Value>> parameters() override {
+        auto params = w;
+        params.push_back(b);
+        return params;
+    }
+
+    friend std::ostream& operator<<(std::ostream& os, const Neuron& neuron) {
+        os << (neuron.nonlin ? "ReLU" : "Linear") << "Neuron(" << neuron.w.size() << ")";
+        return os;
+    }
+};
+
+
+class Layer : public Module {
+public:
+    std::vector<std::shared_ptr<Neuron>> neurons;
+
+    Layer(int nin, int nout, bool nonlin = true) {
+        for (int i = 0; i < nout; ++i) {
+            neurons.push_back(std::make_shared<Neuron>(nin, nonlin));
+        }
+    }
+
+    std::vector<std::shared_ptr<Value>> operator()(const std::vector<std::shared_ptr<Value>>& x) {
+        std::vector<std::shared_ptr<Value>> out;
+        for (auto& neuron : neurons) {
+            out.push_back((*neuron)(x));
+        }
+        return out;
+    }
+
+    std::vector<std::shared_ptr<Value>> parameters() override {
+        std::vector<std::shared_ptr<Value>> params;
+        for (auto& neuron : neurons) {
+            auto neuron_params = neuron->parameters();
+            params.insert(params.end(), neuron_params.begin(), neuron_params.end());
+        }
+        return params;
+    }
+
+    friend std::ostream& operator<<(std::ostream& os, const Layer& layer) {
+        os << "Layer of [";
+        for (size_t i = 0; i < layer.neurons.size(); ++i) {
+            os << *(layer.neurons[i]);
+            if (i != layer.neurons.size() - 1) os << ", ";
+        }
+        os << "]";
+        return os;
+    }
+};
+
+
+class MLP : public Module {
+public:
+    std::vector<std::shared_ptr<Layer>> layers;
+
+    MLP(int nin, const std::vector<int>& nouts) {
+        int sz = nin;
+        for (size_t i = 0; i < nouts.size(); ++i) {
+            layers.push_back(std::make_shared<Layer>(sz, nouts[i], i != nouts.size() - 1));
+            sz = nouts[i];
+        }
+    }
+
+    std::vector<std::shared_ptr<Value>> operator()(const std::vector<std::shared_ptr<Value>>& x) {
+        auto output = x;
+        for (auto& layer : layers) {
+            output = (*layer)(output);
+        }
+        return output;
+    }
+
+    std::vector<std::shared_ptr<Value>> parameters() override {
+        std::vector<std::shared_ptr<Value>> params;
+        for (auto& layer : layers) {
+            auto layer_params = layer->parameters();
+            params.insert(params.end(), layer_params.begin(), layer_params.end());
+        }
+        return params;
+    }
+
+    friend std::ostream& operator<<(std::ostream& os, const MLP& mlp) {
+        os << "MLP of [";
+        for (size_t i = 0; i < mlp.layers.size(); ++i) {
+            os << *(mlp.layers[i]);
+            if (i != mlp.layers.size() - 1) os << ", ";
+        }
+        os << "]";
+        return os;
+    }
+};
+
+#endif // MODULE_H
diff --git a/build.sh b/build.sh
@@ -6,5 +6,20 @@
 # Navigate to the build directory
 cd build
 
-# Run CMake and build
-cmake .. && cmake --build .
+# Configure CMake based on the argument
+if [ "$1" == "test" ]; then
+    cmake -DUSE_TEST=ON ..
+else
+    cmake -DUSE_TEST=OFF ..
+fi
+
+# Build the project
+cmake --build .
+
+# Check if the build was successful
+if [ $? -eq 0 ]; then
+    # Run the executable
+    ./Micrograd
+else
+    echo "Build failed, not running the executable."
+fi
diff --git a/main.cpp b/main.cpp
@@ -0,0 +1,30 @@
+#include "Module.h"
+#include <iostream>
+
+int main() {
+    MLP mlp(3, {4, 4, 1});
+
+    std::vector<std::shared_ptr<Value>> x = {
+        std::make_shared<Value>(1.0),
+        std::make_shared<Value>(-2.0),
+        std::make_shared<Value>(3.0)
+    };
+
+    auto output = mlp(x);
+    output[0]->backward();
+
+    std::cout << "Output: ";
+    for (const auto& val : output) {
+        std::cout << val << " ";
+    }
+    std::cout << std::endl;
+
+    mlp.zero_grad();
+    std::cout << "After zero_grad():" << std::endl;
+    for (const auto& param : mlp.parameters()) {
+        std::cout << param << " ";
+    }
+    std::cout << std::endl;
+
+    return 0;
+}
