Init

TitanicAI.cpp

@@ -0,0 +1,108 @@
+#include <iostream>
+#include <array>
+#include <string>
+
+#include "NeuronsNetworkBase.h"
+
+using data_item = std::array<double, 7>;
+
+class TitanicAI : public NeuronsNetworkBase<data_item>
+{
+    constexpr static size_t count_neurons = 6;
+protected:
+    double activation(double x) override
+    {
+        return 1/(1+exp(-x));
+    }
+    
+public:
+    TitanicAI() : NeuronsNetworkBase(count_neurons, 0.01)
+    {}
+    
+    double call(const data_item& data) override
+    {
+        double sum = 0;
+        for (size_t i = 0; i < count_neurons; ++i)
+        {
+            sum += (*this)[i] * data[i + 1];
+        }
+        
+        return activation(sum);
+    }
+
+    void train(double error, const data_item& data) override
+    {
+        for (size_t i = 0; i < count_neurons; ++i)
+        {
+            (*this)[i] += get_rate_train() * error * data[i + 1];
+        }
+    }
+    
+    void print_masses()
+    {
+        for (size_t i = 0; i < count_neurons; ++i)
+        {
+            std::cout << (*this)[i] << " ";
+        }
+        std::cout << "\n";
+    }
+};
+
+constexpr size_t count_train_items = 700;
+std::vector<data_item> train_data;
+
+int main(int argc, char* argv[])
+{
+    TitanicAI ai;
+    std::ifstream file("train.txt");
+    
+    while (file.eof() == false)
+    {
+        data_item item{};
+        
+        std::string vec;
+        file >> vec;
+        if (vec.empty() == false)
+            item[0] = std::stod(vec);
+        file >> vec;
+        if (vec.empty() == false)
+            item[1] = std::stod(vec);
+        file >> vec;
+        if (vec.empty() == false)
+            item[2] = std::stod(vec);
+        file >> vec;
+        if (vec.empty() == false)
+            item[3] = std::stod(vec);
+        file >> vec;
+        if (vec.empty() == false)
+            item[4] = std::stod(vec);
+        file >> vec;
+        if (vec.empty() == false)
+            item[5] = std::stod(vec);
+        if (vec.empty() == false)
+            item[6] = std::stod(vec);
+        
+        train_data.push_back(item);
+    }
+    
+    for (size_t i = 0; i < count_train_items; ++i)
+    {
+        ai.train(train_data[i][0] - ai.call(train_data[i]), train_data[i]);
+    }
+    
+    size_t score = 0;
+    const size_t max_score = train_data.size() - count_train_items;
+    constexpr double delta = 0.001;
+    for (size_t i = count_train_items + 1; i < train_data.size(); ++i)
+    {
+        double activate_result = ai.call(train_data[i]);
+        bool is_dead =  activate_result + delta > 0.5;
+        if (is_dead == static_cast<bool>(train_data[i][0]))
+            ++score;
+    }
+    
+    std::cout << "Accuracy: " << score << '/' << max_score << " (float: " << (static_cast<double>(score) / static_cast<double>(max_score)) << ")\n";
+    std::cout << "Masses: "; ai.print_masses();
+    
+    return 0;
+}