diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..eae4969
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+cmake-build-debug
+
+build
+
+.idea
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..ea73669
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.23)
+project(MetaAI)
+
+set(CMAKE_CXX_STANDARD 20)
+
+add_executable(MetaAI
+        main.cpp)
diff --git a/Components.h b/Components.h
new file mode 100644
index 0000000..c8c88e0
--- /dev/null
+++ b/Components.h
@@ -0,0 +1,569 @@
+//
+// Created by iku-iku-iku on 2022/10/21.
+//
+
+#ifndef METAAI_COMPONENTS_H
+#define METAAI_COMPONENTS_H
+
+#include <iostream>
+#include "Type.h"
+#include <tuple>
+#include <cstring>
+#include <cmath>
+
+// 定义单操作数的MatrixLikeComponent的N和M
+#define SINGLE_OPERAND_MATRIX_NM  \
+static constexpr std::size_t N = InOperand::N; \
+static constexpr std::size_t M = InOperand::M; \
+//
+
+// 标量
+template<typename T>
+concept Scalar = std::is_scalar_v<T>;
+
+// MatrixVariable和Matrix都是MatrixLike
+// 输出为矩阵的component也可以看成MatrixLike
+template<typename T>
+concept MatrixLike = requires { T::N; T::M; };
+
+// 可优化的类型
+template<typename T>
+concept Optimizable = requires(T t) {
+    &T::step;
+    &T::clear_grad;
+};
+
+// 单独的变量
+template<typename T>
+concept IsSingleVariable = requires{ typename T::VariableClassFlag; };
+
+// 矩阵变量
+template<typename T>
+concept IsMatrixVariable = requires{ typename T::MatrixVariableClassFlag; };
+
+// 变量
+template<typename T>
+concept IsVariable = IsMatrixVariable<T> || IsSingleVariable<T>;
+
+// 利用Component来构建一棵树
+// 将Variable看成一种trivial的component，并且Variable在叶子节点
+template<typename T>
+concept Component = requires(T t) {
+    &T::Backward;
+    &T::Forward;
+    t.whole.data; // 如果是Variable，则为可优化的参数，如果是component，则为中间结果
+    t.whole.grad; // 梯度，反向传播时根据component的求导结果和component的输出来计算得出（链式法则）
+};
+
+template<typename T>
+concept MatrixLikeComponent = Component<T> && MatrixLike<T>;
+
+// CRTP，提供静态多态
+template<typename OpType>
+struct Operator {
+    void Forward() {
+        static_cast<OpType *>(this)->ForwardImpl();
+    }
+
+    void Backward() {
+        static_cast<OpType *>(this)->BackwardImpl();
+    }
+};
+
+
+template<MatrixLikeComponent InOperand1, MatrixLikeComponent InOperand2>
+struct MatMultiply;
+
+template<MatrixLikeComponent InOperand1, MatrixLikeComponent InOperand2>
+struct MatAddition;
+
+template<typename InDataType>
+struct Variable;
+
+template<std::size_t InN, std::size_t InM>
+struct MatrixVariable;
+
+template<typename OperandType>
+struct z_operand_ref {
+    using type = std::remove_reference_t<OperandType>;
+};
+
+// 目前是完全在栈上运算，效率更高，因此需要对于栈上的Variable需要引用
+template<typename InDataType>
+struct z_operand_ref<Variable<InDataType>> {
+    using type = std::remove_reference_t<Variable<InDataType>> &;
+};
+
+template<std::size_t InN, std::size_t InM>
+struct z_operand_ref<MatrixVariable<InN, InM>> {
+    using type = std::remove_reference_t<MatrixVariable<InN, InM>> &;
+};
+
+template<typename InOperandType>
+using operand_ref_t = typename z_operand_ref<InOperandType>::type;
+
+
+// 单独的变量
+template<typename InDataType>
+struct Variable : Operator<Variable<InDataType>> {
+    friend struct Operator<Variable<InDataType>>;
+
+    using VariableClassFlag = std::nullptr_t;
+
+    using DataType = InDataType;
+
+    DataType data{};
+    DataType grad{1}; // 对自己的梯度为1
+
+    Variable &whole;
+
+    Variable() : whole(*this) {}
+
+    explicit Variable(DataType x) : data(x), whole(*this) {}
+
+    friend auto &operator<<(std::ostream &out, const Variable &var) {
+        return out << var.data;
+    }
+
+    DataType value() { return data; }
+
+    DataType gradient() { return grad; }
+
+//    Variable(const Variable &) = delete;
+//
+//    Variable &operator=(const Variable &) = delete;
+
+    // 利用梯度更新参数
+    void step(double lr) {
+        data += -lr * grad;
+    }
+
+    // 清除梯度
+    void clear_grad() {
+        grad = DataType{};
+    }
+
+private:
+    void ForwardImpl() {}
+
+    void BackwardImpl() {}
+};
+
+template<typename... Operands>
+struct VarMultiply : Operator<VarMultiply<Operands...>> {
+    friend struct Operator<VarMultiply<Operands...>>;
+
+    using Whole = Variable<double>;
+
+    std::tuple<Operands &...> operands_tuple;
+
+    Whole whole{}; // 看成一个整体
+
+    explicit VarMultiply(Operands &... operands) : operands_tuple(operands...) {}
+
+private:
+    template<std::size_t... Is>
+    auto VarForwardImpl(std::index_sequence<Is...>) {
+        (get<Is>(operands_tuple).Forward(), ...);
+        return (get<Is>(operands_tuple).value() * ...);
+    }
+
+    void ForwardImpl() {
+        whole.whole.data = VarForwardImpl(std::index_sequence_for<Operands...>{});
+    }
+
+    template<std::size_t... Is>
+    void VarBackwardImpl(std::index_sequence<Is...>) {
+        auto product = (get<Is>(operands_tuple).value() * ...);
+        ((get<Is>(operands_tuple).whole.grad = (whole.grad * product / get<Is>(operands_tuple).value())), ...);
+
+        (get<Is>(operands_tuple).Backward(), ...);
+    }
+
+    void BackwardImpl() {
+        VarBackwardImpl(std::index_sequence_for<Operands...>{});
+    }
+};
+
+// 多个变量求和
+template<typename... Operands>
+struct VarAddition : Operator<VarAddition<Operands...>> {
+    friend struct Operator<VarAddition<Operands...>>;
+
+    using Whole = Variable<double>;
+
+    std::tuple<operand_ref_t<Operands>...> operands_tuple;
+
+    Whole whole{}; // 看成一个整体
+
+    explicit VarAddition(const Operands &... operands) : operands_tuple(const_cast<Operands &>(operands)...) {}
+
+private:
+    template<std::size_t... Is>
+    auto VarForwardImpl(std::index_sequence<Is...>) {
+        (get<Is>(operands_tuple).Forward(), ...);
+        return (get<Is>(operands_tuple).whole.data + ...);
+    }
+
+    void ForwardImpl() {
+        whole.data = VarForwardImpl(std::index_sequence_for<Operands...>{});
+    }
+
+    template<std::size_t... Is>
+    void VarBackwardImpl(std::index_sequence<Is...>) {
+        ((get<Is>(operands_tuple).whole.grad = whole.grad), ...);
+
+        (get<Is>(operands_tuple).Backward(), ...);
+    }
+
+    void BackwardImpl() {
+        VarBackwardImpl(std::index_sequence_for<Operands...>{});
+    }
+};
+
+
+// 向量看成列数为1的矩阵
+template<std::size_t N, typename InDataType = double>
+using Vector = Matrix<N, 1, InDataType>;
+
+// 矩阵变量
+template<std::size_t InN, std::size_t InM>
+struct MatrixVariable : Operator<MatrixVariable<InN, InM>> {
+    friend struct Operator<MatrixVariable<InN, InM>>;
+
+    using MatrixVariableClassFlag = std::nullptr_t;
+
+    static constexpr std::size_t N = InN;
+    static constexpr std::size_t M = InM;
+    using Mat = Matrix<N, M>;
+
+    Mat data; // 变量的值
+    Mat grad; // 变量的梯度
+
+    MatrixVariable &whole;
+
+    void step(double lr) {
+        data += -lr * grad;
+    }
+
+    void clear_grad() {
+        grad = Mat{};
+    }
+
+    void init_grad() {
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                grad.data[i][j] = 1;
+            }
+        }
+    }
+
+    MatrixVariable() : whole(*this) { init_grad(); }
+
+    explicit MatrixVariable(const Matrix<InN, InM> &in_data) : data(in_data), whole(*this) { init_grad(); }
+
+    void set_value(const Mat &value) { data = value; }
+
+
+private:
+    void ForwardImpl() {}
+
+    void BackwardImpl() {}
+};
+
+// 矩阵相乘
+template<MatrixLikeComponent InOperand1, MatrixLikeComponent InOperand2>
+struct MatMultiply : Operator<MatMultiply<InOperand1, InOperand2>> {
+    friend struct Operator<MatMultiply<InOperand1, InOperand2>>;
+
+    using Operand1 = InOperand1;
+    using Operand2 = InOperand2;
+
+    using Whole = MatrixVariable<InOperand1::N, InOperand2::M>;
+
+    static constexpr std::size_t N = InOperand1::N;
+    static constexpr std::size_t M = InOperand2::M;
+
+    Whole whole;
+
+    operand_ref_t<Operand1> operand1; // N * K
+    operand_ref_t<Operand2> operand2; // K * M
+
+    MatMultiply(const InOperand1 &o1, const InOperand2 &o2) : operand1(const_cast<InOperand1 &>(o1)),
+                                                              operand2(const_cast<InOperand2 &>(o2)) {}
+
+private:
+    void ForwardImpl() {
+        operand1.Forward();
+        operand2.Forward();
+        whole.set_value(operand1.whole.data * operand2.whole.data);
+    }
+
+    void BackwardImpl() {
+        // (N, K) * (K, M) => (N, M)
+        // (N, M) * (M, K) => (N, K)
+        // (K, N) * (N, M) => (K, M)
+
+        operand1.whole.grad = whole.grad * operand2.whole.data.T();
+        operand2.whole.grad = operand1.whole.data.T() * whole.grad;
+
+        operand1.Backward();
+        operand2.Backward();
+    }
+};
+
+// 矩阵求和
+template<MatrixLikeComponent InOperand1, MatrixLikeComponent InOperand2>
+struct MatAddition : Operator<MatAddition<InOperand1, InOperand2>> {
+    friend struct Operator<MatAddition<InOperand1, InOperand2>>;
+
+    using Operand1 = InOperand1;
+    using Operand2 = InOperand2;
+
+    using Whole = MatrixVariable<InOperand1::N, InOperand2::M>;
+
+    static constexpr std::size_t N = InOperand1::N;
+    static constexpr std::size_t M = InOperand2::M;
+
+    Whole whole;
+
+    operand_ref_t<Operand1> operand1; // N * M
+    operand_ref_t<Operand2> operand2; // N * M
+
+    MatAddition(const Operand1 &o1, const Operand2 &o2) : operand1(const_cast<Operand1 &>(o1)),
+                                                          operand2(const_cast<Operand2 &>(o2)) {}
+
+private:
+    void ForwardImpl() {
+        operand1.Forward();
+        operand2.Forward();
+
+        whole.data = operand1.whole.data + operand2.whole.data;
+    }
+
+    void BackwardImpl() {
+        operand1.whole.grad = whole.grad;
+        operand2.whole.grad = whole.grad;
+
+        operand1.Backward();
+        operand2.Backward();
+    }
+};
+
+// 对矩阵的每一维求指数运算
+template<MatrixLikeComponent InOperand>
+struct Power : Operator<Power<InOperand>> {
+    friend struct Operator<Power<InOperand>>;
+
+    using Operand = InOperand;
+
+    SINGLE_OPERAND_MATRIX_NM
+
+    using Whole = MatrixVariable<N, M>;
+
+    const unsigned int K; //  求K次方
+
+    operand_ref_t<Operand> operand;
+    Whole whole;
+
+    Power(unsigned int k, const InOperand &o) : K(k), operand(const_cast<InOperand&>(o)) {}
+
+private:
+    void ForwardImpl() {
+        operand.Forward();
+
+        auto &val = operand.whole.data;
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                whole.data[i][j] = std::pow(val[i][j], K);
+            }
+        }
+    }
+
+    void BackwardImpl() {
+        auto &val = operand.whole.data;
+
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                operand.whole.grad[i][j] = whole.grad[i][j] * K * std::pow(val[i][j], K - 1);
+            }
+        }
+
+        operand.Backward();
+    }
+};
+
+// 对矩阵的每个元素进行映射 f(x) = 1 / (1 + exp(-x))
+template<MatrixLikeComponent InOperand>
+struct Sigmoid : Operator<Sigmoid<InOperand>> {
+    friend struct Operator<Sigmoid<InOperand>>;
+
+    using Operand = InOperand;
+
+    SINGLE_OPERAND_MATRIX_NM
+
+    using Whole = MatrixVariable<N, M>;
+
+    operand_ref_t<Operand> operand;
+    Whole whole;
+
+    explicit Sigmoid(const InOperand &o) : operand(const_cast<InOperand &>(o)) {}
+
+    Matrix<Operand::N, Operand::M> &value() { return whole.data; }
+
+private:
+    void ForwardImpl() {
+        operand.Forward();
+
+        auto &val = operand.whole.data;
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                auto &x = val.data[i][j];
+                whole.data[i][j] = 1 / (1 + std::exp(-x));
+            }
+        }
+    }
+
+    void BackwardImpl() {
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                operand.whole.grad[i][j] = whole.grad[i][j] * (1 - whole.data[i][j]) * whole.data[i][j];
+            }
+        }
+
+        operand.Backward();
+    }
+};
+
+// 矩阵乘标量（标量不可优化）
+template<MatrixLikeComponent InOperand, typename ScalarType>
+struct MatScale : Operator<MatScale<InOperand, ScalarType>> {
+    friend struct Operator<MatScale<InOperand, ScalarType>>;
+    SINGLE_OPERAND_MATRIX_NM
+
+    using Operand = InOperand;
+    using Whole = MatrixVariable<InOperand::N, InOperand::M>;
+
+
+    Whole whole;
+
+    operand_ref_t<InOperand> operand;
+    ScalarType scalar;
+
+    MatScale(const Operand &o, ScalarType scalar_) : operand(const_cast<InOperand &>(o)), scalar(scalar_) {}
+
+private:
+    void ForwardImpl() {
+        operand.Forward();
+
+        for (int i = 0; i < N; ++i) {
+            for (int j = 0; j < M; ++j) {
+                whole.data[i][j] = scalar * operand.whole.data[i][j];
+            }
+        }
+    }
+
+    void BackwardImpl() {
+        for (int i = 0; i < N; ++i) {
+            for (int j = 0; j < M; ++j) {
+                operand.whole.grad[i][j] = scalar * whole.grad[i][j];
+            }
+        }
+
+        operand.Backward();
+    }
+};
+
+// 将矩阵的所有元素加起来
+template<MatrixLikeComponent InOperand>
+struct Sum : Operator<Sum<InOperand>> {
+    friend struct Operator<Sum<InOperand>>;
+
+    using Operand = InOperand;
+
+    using Whole = Variable<double>;
+
+    Whole whole;
+
+    operand_ref_t<Operand> operand;
+
+    explicit Sum(const InOperand &o) : operand(const_cast<InOperand &>(o)) {}
+
+private:
+    void ForwardImpl() {
+        operand.Forward();
+
+        whole.whole.data = 0;
+
+        auto &val = operand.whole.data;
+        for (int i = 0; i < InOperand::N; i++) {
+            for (int j = 0; j < InOperand::M; j++) {
+                whole.whole.data = whole.value() + val[i][j];
+            }
+        }
+    }
+
+    void BackwardImpl() {
+        for (int i = 0; i < InOperand::N; i++) {
+            for (int j = 0; j < InOperand::M; j++) {
+                operand.whole.grad[i][j] = whole.gradient();
+            }
+        }
+
+        operand.Backward();
+    }
+};
+
+template<Optimizable... T>
+inline void step(double lr, T &... variables) {
+    (variables.step(lr), ...);
+    (variables.clear_grad(), ...);
+}
+
+template<MatrixLikeComponent LHS, MatrixLikeComponent RHS>
+inline auto operator*(const LHS &lhs, const RHS &rhs) {
+    return MatMultiply{lhs, rhs};
+}
+
+template<Scalar ScalarType, MatrixLikeComponent RHS>
+inline auto operator*(ScalarType scalar, const RHS &rhs) {
+    return MatScale{rhs, scalar};
+}
+
+template<Scalar ScalarType, MatrixLikeComponent LHS>
+inline auto operator*(const LHS &lhs, ScalarType scalar) {
+    return MatScale{lhs, scalar};
+}
+
+template<MatrixLikeComponent LHS, MatrixLikeComponent RHS>
+requires (IsMatrixVariable<LHS> || IsMatrixVariable<typename LHS::Whole>) &&
+         (IsMatrixVariable<RHS> || IsMatrixVariable<typename RHS::Whole>)
+inline auto operator+(const LHS &lhs, const RHS &rhs) {
+    return MatAddition{lhs, rhs};
+}
+
+template<Component LHS, Component RHS>
+requires (IsSingleVariable<LHS> || IsSingleVariable<typename LHS::Whole>) &&
+         (IsSingleVariable<RHS> || IsSingleVariable<typename RHS::Whole>)
+inline auto operator+(const LHS &lhs, const RHS &rhs) {
+    return VarAddition{lhs, rhs};
+}
+
+template<MatrixLikeComponent LHS, MatrixLikeComponent RHS>
+inline auto operator-(const LHS &lhs, const RHS &rhs) {
+    return lhs + (-rhs);
+}
+
+// 用^模拟指数运算符，注意^的优先级低于+
+template<MatrixLikeComponent LHS>
+inline auto operator^(const LHS &lhs, unsigned int k) {
+    return Power{k, lhs};
+}
+
+// 乘以-1
+template<MatrixLikeComponent LHS>
+inline auto operator-(const LHS &lhs) {
+    return MatScale{lhs, -1};
+}
+
+#endif //METAAI_COMPONENTS_H
diff --git a/Data.h b/Data.h
new file mode 100644
index 0000000..eece080
--- /dev/null
+++ b/Data.h
@@ -0,0 +1,140 @@
+//
+// Created by iku-iku-iku on 2022/10/21.
+//
+
+#ifndef METAAI_DATA_H
+#define METAAI_DATA_H
+
+#include "Components.h"
+#include <fstream>
+
+
+template<typename T>
+inline auto mean(std::vector<T> &vec) {
+    T sum{};
+    for (const auto &x: vec) {
+        sum += x;
+    }
+
+    return sum * 1.0 / vec.size();
+}
+
+template<typename T>
+inline auto deviation(std::vector<T> &vec) {
+    T sqrt_sum{};
+    for (const auto &x: vec) {
+        sqrt_sum += x * x;
+    }
+    auto mean_value = mean(vec);
+    return sqrt_sum * 1.0 / vec.size() - mean_value * mean_value;
+}
+
+template<typename T>
+inline auto sigma(std::vector<T> &vec) {
+    return std::sqrt(deviation(vec));
+}
+
+template<std::size_t N, typename ElemType>
+auto read_vector(std::stringstream &ss) {
+    Vector<N, ElemType> vec;
+
+    for (int i = 0; i < N; i++) {
+        ss >> vec.data[i][0];
+    }
+
+    return vec;
+}
+
+template<typename T>
+auto read_elem(std::stringstream &ss) {
+    T t;
+    ss >> t;
+    return t;
+}
+
+template<std::size_t N>
+auto one_hot(std::size_t i) {
+    Vector<N> vec;
+    vec.data[i][0] = 1;
+    return vec;
+}
+
+template<std::size_t N, typename DataType>
+auto max_i(Vector<N, DataType> &vec) {
+    std::size_t res = -1;
+    DataType max_v = -1e9;
+    for (std::size_t i = 0; i < N; ++i) {
+        if (vec.data[i][0] > max_v) {
+            max_v = vec.data[i][0];
+            res = i;
+        }
+    }
+    return res;
+}
+
+template<std::size_t FeatN, typename InFeatureType = double, typename InLabelType = int>
+struct Dataset {
+    using FeatureType = InFeatureType;
+    using LabelType = InLabelType;
+
+    using VecType = Vector<FeatN, FeatureType>;
+
+    std::vector<VecType> features;
+
+    std::vector<LabelType> labels;
+
+    void read_from_file(const char *path) {
+        std::ifstream ifs;
+
+        ifs.open(path, std::ios::in);
+
+        std::stringstream ss;
+        char buf[256];
+        while (ifs.getline(buf, sizeof(buf))) {
+            ss << buf;
+            features.push_back(read_vector<FeatN, FeatureType>(ss));
+            labels.push_back(read_elem<LabelType>(ss));
+        }
+
+        ifs.close();
+    }
+
+    void normalize() {
+        for (int i = 0; i < FeatN; i++) {
+            FeatureType min_v = 1e9, max_v = -1e9;
+            for (auto &vec: features) {
+                min_v = std::min(min_v, vec.get(i));
+                max_v = std::max(max_v, vec.get(i));
+            }
+
+            for (auto &vec: features) {
+                vec.get(i) = (vec.get(i) - min_v) / (max_v - min_v);
+            }
+        }
+    }
+
+
+    void normalize2() {
+        for (int i = 0; i < FeatN; i++) {
+            std::vector<FeatureType> vec;
+            for (auto &feat: features) {
+                vec.push_back(feat.get(i));
+            }
+
+            auto mu = mean(vec);
+            auto sig = sigma(vec);
+
+            for (auto &feat: features) {
+                feat.get(i) = (feat.get(i) - mu) / sig;
+            }
+        }
+    }
+
+    VecType &get_feature(std::size_t i) { return features[i]; }
+
+    LabelType &get_label(std::size_t i) { return labels[i]; }
+
+    std::size_t size() { return features.size(); }
+};
+
+#endif //METAAI_DATA_H
diff --git a/Dict.h b/Dict.h
new file mode 100644
index 0000000..145c6db
--- /dev/null
+++ b/Dict.h
@@ -0,0 +1,124 @@
+//
+// Created by iku-iku-iku on 2022/10/20.
+//
+
+#ifndef METAAI_DICT_H
+#define METAAI_DICT_H
+
+#include <tuple>
+#include <memory>
+
+struct A {
+};
+struct B {
+};
+struct C {
+};
+
+template<bool A, typename B, typename C>
+struct condition {
+    using type = B;
+};
+
+template<typename B, typename C>
+struct condition<false, B, C> {
+    using type = C;
+};
+
+template<typename T1, typename T2>
+constexpr auto is_same_type = false;
+
+template<typename T>
+constexpr auto is_same_type<T, T> = true;
+
+
+template<typename... VarKeys>
+struct Dict {
+
+    template<typename T>
+    static constexpr auto GetIndex() {
+        return Find<0, T, VarKeys...>();
+    }
+
+    template<std::size_t i, typename T1>
+    static constexpr auto Find() {
+        return -1;
+    }
+
+    template<std::size_t i, typename T1, typename T2, typename... Types>
+    static constexpr auto Find() {
+        if constexpr (is_same_type<T1, T2>) {
+            return i;
+        } else {
+            return Find<i + 1, T1, Types...>();
+        }
+    }
+    template<typename... Args>
+    struct Values {
+        template<std::size_t I, typename CurType, typename... Types>
+        struct Type {
+            using type = typename Type<I - 1, Types...>::type;
+        };
+
+        template<typename CurType, typename... Types>
+        struct Type<0, CurType, Types...> {
+            using type = CurType;
+        };
+
+        template<std::size_t I>
+        using GetType = typename Type<I, Args...>::type;
+
+
+        std::shared_ptr<void> m_Tuple[sizeof...(Args)];
+
+        template<typename KeyType, typename ValueType>
+        constexpr auto Set(ValueType &&val) {
+            constexpr auto index = GetIndex<KeyType>();
+            using RawValType = std::decay_t<ValueType>;
+            using New = Replace<RawValType, index, Values<>, Args...>;
+            auto n = New();
+            for (int i = 0; i < sizeof...(Args); i++) {
+                if (i != index) { n.m_Tuple[i] = std::move(m_Tuple[i]); }
+                else {
+                    n.m_Tuple[i] = std::shared_ptr<void>(new RawValType(std::forward<ValueType>(val)), [](void *ptr) {
+                        auto p = static_cast<RawValType *>(ptr);
+                        delete p;
+                    });
+                }
+            }
+            return n;
+        }
+
+        template<typename Key>
+        [[nodiscard]] auto& Get() const {
+            constexpr auto index = GetIndex<Key>();
+            using ValType = GetType<index>;
+            return *reinterpret_cast<ValType *>(m_Tuple[index].get());
+        }
+
+        template<typename NewType, std::size_t I, std::size_t Index, typename PreTypes,
+                typename CurType, typename... RemainTypes>
+        struct Replace_;
+
+        template<typename NewType, std::size_t I, std::size_t Index, template<typename...> class PreTypes,
+                typename... Traveled, typename CurType, typename... RemainTypes>
+        struct Replace_<NewType, I, Index, PreTypes<Traveled...>, CurType, RemainTypes...> {
+            using type = typename Replace_<NewType, I + 1, Index, PreTypes<Traveled..., CurType>, RemainTypes...>::type;
+        };
+        template<typename NewType, std::size_t Index, template<typename...> class PreTypes,
+                typename... Traveled, typename CurType, typename... RemainTypes>
+        struct Replace_<NewType, Index, Index, PreTypes<Traveled...>, CurType, RemainTypes...> {
+            using type = PreTypes<Traveled..., NewType, RemainTypes...>;
+        };
+
+        template<typename NewType, std::size_t Index, typename PreTypes, typename... RemainTypes>
+        using Replace = typename Replace_<NewType, 0, Index, PreTypes, RemainTypes...>::type;
+
+    };
+
+    using Keys = Values<VarKeys...>;
+
+    static constexpr auto Create() { return Keys(); }
+};
+
+#endif //METAAI_DICT_H
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..48e5dea
--- /dev/null
+++ b/README.md
@@ -0,0 +1,20 @@
+C++元编程实现AI框架
+
+> 元编程真好玩，就是头有点凉
+
+编译器需要支持C++20
+
+实现了若干Operator，目前利用Operator来组装网络
+
+重载了+*^-操作符方便模型构建
+
+主要思路为：
+1. Forward时把计算结果存储到whole中 (后序遍历：先对Operand进行Forward，在计算当前Component的结果)
+2. Backward时利用whole的grad来计算operand的grad (前序遍历：先计算operand的grad，再对operand进行Backward)
+
+使用到的新特性
+1. auto返回值类型推导
+2. 类模板参数推导
+3. concept和requires
+4. fold expression
+5. alias template
\ No newline at end of file
diff --git a/Train.h b/Train.h
new file mode 100644
index 0000000..ef4d278
--- /dev/null
+++ b/Train.h
@@ -0,0 +1,47 @@
+//
+// Created by iku-iku-iku on 2022/10/21.
+//
+
+#ifndef METAAI_TRAIN_H
+#define METAAI_TRAIN_H
+
+#include <tuple>
+#include "Components.h"
+
+struct LrScheduler {
+    double lr;
+    double decay_rate;
+
+    LrScheduler(double init_lr = 0.985, double decay_rate_ = 0.985) : lr(init_lr), decay_rate(decay_rate_) {}
+
+    double get() { return lr; }
+
+    double next() { lr *= decay_rate; return lr;}
+};
+
+template<Component Model, typename... Param>
+struct Plan {
+    LrScheduler scheduler;
+
+    Model model;
+
+    std::tuple<Param &...> param_tuple;
+
+
+    Plan(LrScheduler scheduler_, Model model_, Param &... param) : scheduler(scheduler_), model(model_), param_tuple(param...) {}
+
+    template<std::size_t... Is>
+    void optimize(std::index_sequence<Is...>) {
+        auto lr = scheduler.next();
+        (get<Is>(param_tuple).step(lr), ...);
+        (get<Is>(param_tuple).clear_grad(), ...);
+    }
+
+    void step() {
+        model.Forward();
+        model.Backward();
+        optimize(std::index_sequence_for<Param...>{});
+    }
+};
+
+#endif //METAAI_TRAIN_H
diff --git a/Type.h b/Type.h
new file mode 100644
index 0000000..873f84b
--- /dev/null
+++ b/Type.h
@@ -0,0 +1,134 @@
+//
+// Created by iku-iku-iku on 2022/10/21.
+//
+
+#ifndef METAAI_TYPE_H
+#define METAAI_TYPE_H
+
+#include <cstring>
+
+// 矩阵，可以看成基本类型
+template<std::size_t In_N, std::size_t In_M, typename InDataType = double>
+struct Matrix {
+    using DataType = InDataType;
+    static constexpr std::size_t N = In_N;
+    static constexpr std::size_t M = In_M;
+
+    DataType data[N][M]{};
+
+    Matrix() = default;
+
+    Matrix(DataType in_data[N][M]) { std::memcpy(data, in_data, sizeof(data)); }
+
+    // 根据传入的随机数生成器生成矩阵
+    template<typename Gen>
+    static Matrix RandomlyCreate(Gen gen) {
+        Matrix res;
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                res.data[i][j] = gen();
+            }
+        }
+        return res;
+    }
+
+    DataType& get(std::size_t i , std::size_t j = 0) {
+        return data[i][j];
+    }
+
+    DataType value() { return data; }
+
+    Matrix(const Matrix &) = default;
+
+    Matrix &operator=(const Matrix &) = default;
+
+    void ForwardImpl() {}
+
+    void BackwardImpl() {}
+
+    template<std::size_t R_N, std::size_t R_M>
+    Matrix<N, R_M> operator*(const Matrix<R_N, R_M> &rhs) {
+        Matrix<N, R_M> res;
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < R_M; j++) {
+                for (int k = 0; k < R_N; k++) {
+                    res.data[i][j] += data[i][k] * rhs.data[k][j];
+                }
+            }
+        }
+        return res;
+    }
+
+    Matrix operator+(const Matrix &rhs) {
+        Matrix res;
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                res.data[i][j] = data[i][j] + rhs.data[i][j];
+            }
+        }
+        return res;
+    }
+
+    Matrix operator-() {
+        Matrix res = *this;
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                res.data[i][j] = -data[i][j];
+            }
+        }
+        return res;
+    }
+
+    Matrix<M, N> T() {
+        Matrix<M, N> res;
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                res.data[j][i] = data[i][j];
+            }
+        }
+        return res;
+    }
+
+    DataType *operator[](std::size_t i) {
+        return data[i];
+    }
+
+    Matrix &operator+=(const Matrix &rhs) {
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                data[i][j] += rhs.data[i][j];
+            }
+        }
+        return *this;
+    }
+
+    template<typename T>
+    friend Matrix operator*(const Matrix &mat, const T &scalar) {
+        Matrix res(mat);
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                res.data[i][j] *= scalar;
+            }
+        }
+        return res;
+    }
+
+    template<typename T>
+    friend Matrix operator*(const T &scalar, const Matrix &mat) {
+        return mat * scalar;
+    }
+
+    friend auto &operator<<(std::ostream &out, const Matrix &var) {
+        std::cout << "data:" << std::endl;
+        for (int i = 0; i < N; i++) {
+            out << '\t';
+            for (int j = 0; j < M; j++) {
+                out << var.data[i][j] << ' ';
+            }
+            out << std::endl;
+        }
+        return out;
+    }
+};
+
+#endif //METAAI_TYPE_H
diff --git a/Util.h b/Util.h
new file mode 100644
index 0000000..9613dcd
--- /dev/null
+++ b/Util.h
@@ -0,0 +1,17 @@
+//
+// Created by iku-iku-iku on 2022/10/21.
+//
+
+#ifndef METAAI_UTIL_H
+#define METAAI_UTIL_H
+
+#include <iostream>
+
+inline auto print() {std::cout << std::endl;}
+template<typename G, typename... T>
+inline auto print(G g, T&&... var) {
+    std::cout << g << " ";
+    print(var...);
+}
+
+#endif //METAAI_UTIL_H
diff --git a/data/Iris-test.txt b/data/Iris-test.txt
new file mode 100644
index 0000000..91a6408
--- /dev/null
+++ b/data/Iris-test.txt
@@ -0,0 +1,75 @@
+5.0 3.0 1.6 0.2 0 
+5.0 3.4 1.6 0.4 0 
+5.2 3.5 1.5 0.2 0 
+5.2 3.4 1.4 0.2 0 
+4.7 3.2 1.6 0.2 0 
+4.8 3.1 1.6 0.2 0 
+5.4 3.4 1.5 0.4 0 
+5.2 4.1 1.5 0.1 0 
+5.5 4.2 1.4 0.2 0 
+4.9 3.1 1.5 0.1 0 
+5.0 3.2 1.2 0.2 0 
+5.5 3.5 1.3 0.2 0 
+4.9 3.1 1.5 0.1 0 
+4.4 3.0 1.3 0.2 0 
+5.1 3.4 1.5 0.2 0 
+5.0 3.5 1.3 0.3 0 
+4.5 2.3 1.3 0.3 0 
+4.4 3.2 1.3 0.2 0 
+5.0 3.5 1.6 0.6 0 
+5.1 3.8 1.9 0.4 0 
+4.8 3.0 1.4 0.3 0 
+5.1 3.8 1.6 0.2 0 
+4.6 3.2 1.4 0.2 0 
+5.3 3.7 1.5 0.2 0 
+5.0 3.3 1.4 0.2 0 
+6.6 3.0 4.4 1.4 1 
+6.8 2.8 4.8 1.4 1 
+6.7 3.0 5.0 1.7 1 
+6.0 2.9 4.5 1.5 1 
+5.7 2.6 3.5 1.0 1 
+5.5 2.4 3.8 1.1 1 
+5.5 2.4 3.7 1.0 1 
+5.8 2.7 3.9 1.2 1 
+6.0 2.7 5.1 1.6 1 
+5.4 3.0 4.5 1.5 1 
+6.0 3.4 4.5 1.6 1 
+6.7 3.1 4.7 1.5 1 
+6.3 2.3 4.4 1.3 1 
+5.6 3.0 4.1 1.3 1 
+5.5 2.5 4.0 1.3 1 
+5.5 2.6 4.4 1.2 1 
+6.1 3.0 4.6 1.4 1 
+5.8 2.6 4.0 1.2 1 
+5.0 2.3 3.3 1.0 1 
+5.6 2.7 4.2 1.3 1 
+5.7 3.0 4.2 1.2 1 
+5.7 2.9 4.2 1.3 1 
+6.2 2.9 4.3 1.3 1 
+5.1 2.5 3.0 1.1 1 
+5.7 2.8 4.1 1.3 1 
+7.2 3.2 6.0 1.8 2 
+6.2 2.8 4.8 1.8 2 
+6.1 3.0 4.9 1.8 2 
+6.4 2.8 5.6 2.1 2 
+7.2 3.0 5.8 1.6 2 
+7.4 2.8 6.1 1.9 2 
+7.9 3.8 6.4 2.0 2 
+6.4 2.8 5.6 2.2 2 
+6.3 2.8 5.1 1.5 2 
+6.1 2.6 5.6 1.4 2 
+7.7 3.0 6.1 2.3 2 
+6.3 3.4 5.6 2.4 2 
+6.4 3.1 5.5 1.8 2 
+6.0 3.0 4.8 1.8 2 
+6.9 3.1 5.4 2.1 2 
+6.7 3.1 5.6 2.4 2 
+6.9 3.1 5.1 2.3 2 
+5.8 2.7 5.1 1.9 2 
+6.8 3.2 5.9 2.3 2 
+6.7 3.3 5.7 2.5 2 
+6.7 3.0 5.2 2.3 2 
+6.3 2.5 5.0 1.9 2 
+6.5 3.0 5.2 2.0 2 
+6.2 3.4 5.4 2.3 2 
+5.9 3.0 5.1 1.8 2 
\ No newline at end of file
diff --git a/data/Iris-train.txt b/data/Iris-train.txt
new file mode 100644
index 0000000..997e68d
--- /dev/null
+++ b/data/Iris-train.txt
@@ -0,0 +1,75 @@
+5.1 3.5 1.4 0.2 0 
+4.9 3.0 1.4 0.2 0 
+4.7 3.2 1.3 0.2 0 
+4.6 3.1 1.5 0.2 0 
+5.0 3.6 1.4 0.2 0 
+5.4 3.9 1.7 0.4 0 
+4.6 3.4 1.4 0.3 0 
+5.0 3.4 1.5 0.2 0 
+4.4 2.9 1.4 0.2 0 
+4.9 3.1 1.5 0.1 0 
+5.4 3.7 1.5 0.2 0 
+4.8 3.4 1.6 0.2 0 
+4.8 3.0 1.4 0.1 0 
+4.3 3.0 1.1 0.1 0 
+5.8 4.0 1.2 0.2 0 
+5.7 4.4 1.5 0.4 0 
+5.4 3.9 1.3 0.4 0 
+5.1 3.5 1.4 0.3 0 
+5.7 3.8 1.7 0.3 0 
+5.1 3.8 1.5 0.3 0 
+5.4 3.4 1.7 0.2 0 
+5.1 3.7 1.5 0.4 0 
+4.6 3.6 1.0 0.2 0 
+5.1 3.3 1.7 0.5 0 
+4.8 3.4 1.9 0.2 0 
+7.0 3.2 4.7 1.4 1 
+6.4 3.2 4.5 1.5 1 
+6.9 3.1 4.9 1.5 1 
+5.5 2.3 4.0 1.3 1 
+6.5 2.8 4.6 1.5 1 
+5.7 2.8 4.5 1.3 1 
+6.3 3.3 4.7 1.6 1 
+4.9 2.4 3.3 1.0 1 
+6.6 2.9 4.6 1.3 1 
+5.2 2.7 3.9 1.4 1 
+5.0 2.0 3.5 1.0 1 
+5.9 3.0 4.2 1.5 1 
+6.0 2.2 4.0 1.0 1 
+6.1 2.9 4.7 1.4 1 
+5.6 2.9 3.6 1.3 1 
+6.7 3.1 4.4 1.4 1 
+5.6 3.0 4.5 1.5 1 
+5.8 2.7 4.1 1.0 1 
+6.2 2.2 4.5 1.5 1 
+5.6 2.5 3.9 1.1 1 
+5.9 3.2 4.8 1.8 1 
+6.1 2.8 4.0 1.3 1 
+6.3 2.5 4.9 1.5 1 
+6.1 2.8 4.7 1.2 1 
+6.4 2.9 4.3 1.3 1 
+6.3 3.3 6.0 2.5 2 
+5.8 2.7 5.1 1.9 2 
+7.1 3.0 5.9 2.1 2 
+6.3 2.9 5.6 1.8 2 
+6.5 3.0 5.8 2.2 2 
+7.6 3.0 6.6 2.1 2 
+4.9 2.5 4.5 1.7 2 
+7.3 2.9 6.3 1.8 2 
+6.7 2.5 5.8 1.8 2 
+7.2 3.6 6.1 2.5 2 
+6.5 3.2 5.1 2.0 2 
+6.4 2.7 5.3 1.9 2 
+6.8 3.0 5.5 2.1 2 
+5.7 2.5 5.0 2.0 2 
+5.8 2.8 5.1 2.4 2 
+6.4 3.2 5.3 2.3 2 
+6.5 3.0 5.5 1.8 2 
+7.7 3.8 6.7 2.2 2 
+7.7 2.6 6.9 2.3 2 
+6.0 2.2 5.0 1.5 2 
+6.9 3.2 5.7 2.3 2 
+5.6 2.8 4.9 2.0 2 
+7.7 2.8 6.7 2.0 2 
+6.3 2.7 4.9 1.8 2 
+6.7 3.3 5.7 2.1 2 
diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..b377157
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,110 @@
+//
+// Created by iku-iku-iku on 2022/10/19.
+//
+
+#include <random>
+#include <chrono>
+#include <sstream>
+#include "Components.h"
+#include "Data.h"
+#include "Util.h"
+
+
+auto RandomGenerator(unsigned seed) {
+    std::default_random_engine gen(seed);
+    std::normal_distribution<double> dis(0, 1);
+    return std::make_tuple(dis, gen);
+}
+
+#define MV(NAME, N, M, g) \
+auto NAME##_mat = Matrix<N, M>::RandomlyCreate(g); \
+MatrixVariable NAME{NAME##_mat};                                  \
+//
+
+void train(auto &w1, auto &b1, auto &w2, auto &b2) {
+    Dataset<4> train_dataset;
+    train_dataset.read_from_file("../data/Iris-train.txt");
+//    train_dataset.normalize();
+
+
+    const int epoch = 200;
+//    const int epoch = 40;
+    for (int e_i = 0; e_i < epoch; ++e_i) {
+        double total_loss = 0;
+        for (int d_i = 0; d_i < train_dataset.size(); ++d_i) {
+            MatrixVariable x{train_dataset.get_feature(d_i)};
+            MatrixVariable y{one_hot<3>(train_dataset.get_label(d_i))};
+
+            // 组装
+            auto a1 = Sigmoid{w1 * x + b1};
+
+            auto a2 = Sigmoid{w2 * a1 + b2};
+
+            auto loss = Sum{((a2 - y) ^ 2) * 0.5};
+
+
+            loss.Forward();
+            loss.Backward();
+
+            step(0.9 * std::pow(0.985, e_i), w2, w1, b2, b1);
+
+            total_loss += loss.whole.value();
+        }
+    }
+}
+
+auto test(auto &w1, auto &b1, auto &w2, auto &b2) {
+    Dataset<4> test_dataset;
+    test_dataset.read_from_file("../data/Iris-test.txt");
+//    test_dataset.normalize();
+
+    int total = 0, right = 0;
+    for (int d_i = 0; d_i < test_dataset.size(); ++d_i) {
+        MatrixVariable x{test_dataset.get_feature(d_i)};
+
+        // 组装
+        auto a1 = Sigmoid{w1 * x + b1};
+
+        auto pred = Sigmoid{w2 * a1 + b2};
+
+        pred.Forward();
+
+        total++;
+        right += test_dataset.get_label(d_i) == max_i(pred.whole.data);
+    }
+
+    return 1.0 * right / total;
+}
+
+#define RANDOM
+
+int main() {
+    std::vector<double> accuracy_vec;
+    for (int i = 0; i < 10; i++) {
+
+#ifdef RANDOM
+        auto seed = std::chrono::system_clock::now().time_since_epoch().count();
+#else
+        auto seed = 0;
+#endif
+        auto t = RandomGenerator(seed);
+        auto g = [&t] { return get<0>(t)(get<1>(t)); };
+
+        MV(w1, 10, 4, g)
+        MV(w2, 3, 10, g)
+        MV(b1, 10, 1, g)
+        MV(b2, 3, 1, g)
+
+        train(w1, b1, w2, b2);
+        auto accuracy = test(w1, b1, w2, b2);
+        accuracy_vec.push_back(accuracy);
+    }
+
+    for (const auto& acc : accuracy_vec) {
+        print("accuracy:", acc);
+    }
+
+    print("sigma:", sigma(accuracy_vec));
+    print("mean:", mean(accuracy_vec));
+
+}
\ No newline at end of file
diff --git a/test.cpp b/test.cpp
new file mode 100644
index 0000000..a6f910c
--- /dev/null
+++ b/test.cpp
@@ -0,0 +1,42 @@
+//
+// Created by iku-iku-iku on 2022/10/21.
+//
+#include "Components.h"
+#include "Util.h"
+
+void test1() {
+    auto v1 = Variable(1);
+    auto v2 = Variable(2);
+    auto v3 = Variable(3);
+    auto v4 = Variable(4);
+    auto v5 = Variable(5);
+    auto v6 = Variable(6);
+    auto v7 = Variable(7);
+
+    VarMultiply layer2{v5, v6, v7};
+
+    VarAddition layer3{v1, v2, v3, v4, layer2};
+    layer3.Forward();
+    layer3.Backward();
+
+    print(v1.gradient(), v2.gradient(), v3.gradient(), v4.gradient(), v5.gradient(), v6.gradient(), v7.gradient());
+}
+
+void test2() {
+    double mat1[2][2] = {{2, 0},
+                         {1, 2}};
+    double mat2[2][2] = {{1, 0},
+                         {3, 0}};
+    Matrix<2, 2> m1{mat1};
+    Matrix<2, 2> m2{mat2};
+
+    MatrixVariable mv1{m1};
+    MatrixVariable mv2{m2};
+
+    MatAddition layer{mv1, mv2};
+
+    layer.Forward();
+    layer.Backward();
+    std::cout << mv2.grad;
+}
+