Примеры из "СРР для новичков-важно" не идут

#include <iostream>
#include <vector>
#include <cmath>
#include <random>
 
class OurNeuralNetwork {
public:
    OurNeuralNetwork() {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::normal_distribution<> d(0, 1);
 
        // Weights
        w1 = d(gen);
        w2 = d(gen);
        w3 = d(gen);
        w4 = d(gen);
        w5 = d(gen);
        w6 = d(gen);
 
        // Biases
        b1 = d(gen);
        b2 = d(gen);
        b3 = d(gen);
    }
 
    double sigmoid(double x) {
        return 1 / (1 + exp(-x));
    }
 
    double deriv_sigmoid(double x) {
        double fx = sigmoid(x);
        return fx * (1 - fx);
    }
 
    double mse_loss(const std::vector<double>& y_true, const std::vector<double>& y_pred) {
        double loss = 0;
        for (size_t i = 0; i < y_true.size(); ++i) {
            loss += pow(y_true[i] - y_pred[i], 2);
        }
        return loss / y_true.size();
    }
 
    double feedforward(const std::vector<double>& x) {
        double h1 = sigmoid(w1 * x[0] + w2 * x[1] + b1);
        double h2 = sigmoid(w3 * x[0] + w4 * x[1] + b2);
        double o1 = sigmoid(w5 * h1 + w6 * h2 + b3);
        return o1;
    }
 
    void train(const std::vector<std::vector<double>>& data, const std::vector<double>& all_y_trues) {
        double learn_rate = 0.1;
        int epochs = 1000;  // number of passes through the dataset
        for (int epoch = 0; epoch < epochs; ++epoch) {
            for (size_t i = 0; i < data.size(); ++i) {
                const auto& x = data[i];
                double y_true = all_y_trues[i];
 
                // --- Forward pass
                double sum_h1 = w1 * x[0] + w2 * x[1] + b1;
                double h1 = sigmoid(sum_h1);
                double sum_h2 = w3 * x[0] + w4 * x[1] + b2;
                double h2 = sigmoid(sum_h2);
                double sum_o1 = w5 * h1 + w6 * h2 + b3;
                double y_pred = sigmoid(sum_o1);
                double d_L_d_ypred = -2 * (y_true - y_pred);
                double d_ypred_d_w5 = h1 * deriv_sigmoid(sum_o1);
                double d_ypred_d_w6 = h2 * deriv_sigmoid(sum_o1);
                double d_ypred_d_b3 = deriv_sigmoid(sum_o1);
                double d_ypred_d_h1 = w5 * deriv_sigmoid(sum_o1);
                double d_ypred_d_h2 = w6 * deriv_sigmoid(sum_o1);
                double d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1);
                double d_h1_d_w2 = x[1] * deriv_sigmoid(sum_h1);
                double d_h1_d_b1 = deriv_sigmoid(sum_h1);
                double d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2);
                double d_h2_d_w4 = x[1] * deriv_sigmoid(sum_h2);
                double d_h2_d_b2 = deriv_sigmoid(sum_h2);
 
                w1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w1;
                w2 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w2;
                b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1;
                w3 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w3;
                w4 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w4;
                b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_b2;
                w5 -= learn_rate * d_L_d_ypred * d_ypred_d_w5;
                w6 -= learn_rate * d_L_d_ypred * d_ypred_d_w6;
                b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3;
            }
            if (epoch % 10 == 0) {
                std::vector<double> y_preds;
                for (const auto& x : data) {
                    y_preds.push_back(feedforward(x));
                }
                double loss = mse_loss(all_y_trues, y_preds);
                std::cout << "Epoch " << epoch << " loss: " << loss << std::endl;
            }
        }
    }
 
private:
    double w1, w2, w3, w4, w5, w6;
    double b1, b2, b3;
};
 
int main() {
    std::vector<std::vector<double>> data = {
        {-2, -1},  // Alice
        {25, 6},   // Bob
        {17, 4},   // Charlie
        {-15, -6}  // Diana
    };
    std::vector<double> all_y_trues = {
        1, // Alice
        0, // Bob
        0, // Charlie
        1  // Diana
    };
 
    OurNeuralNetwork network;
    network.train(data, all_y_trues);
 
    std::vector<double> emily = { -7, -3 };  // 128 pounds, 63 inches
    std::vector<double> frank = { 20, 2 };   // 155 pounds, 68 inches
 
    std::cout << "Emily: " << network.feedforward(emily) << std::endl; // 0.951 - Female
    std::cout << "Frank: " << network.feedforward(frank) << std::endl; // 0.039 - Male
 
    return 0;
}

#include <iostream>
#include <ctime>
#include <string>
#include <algorithm>
#include <sstream>
#include <iomanip>
using namespace std;
class Exeption // класс для исключений
{
  private:
    string problem; // описание проблемы
    int number; // номер числа или проблемы
  public:
    Exeption(char e, int num);
    void writeexept(); // вывести проблему
};
 
Exeption::Exeption(char e, int num = 0)
{
    switch (e)
    {
    case 'd':
        problem = "Неверный день";
        break;
    case 'm':
        problem = "Неверный месяц";
        break;
    case 'y':
        problem = "Неверный год";
        break;
    default:
        problem = "Неизвестная проблема";
        break;
    }
    number = num;
}
 
void Exeption::writeexept()
{
    if (problem == "")
        return;
    else
        cerr << problem << ": " << number << endl;
    return;
}
 
class Date //класс для работы с датами от Р.Х.
{
  private:
    int day, month, year;
  public:
    Date(string s);
    Date(int d, int m, int y);
    void clear() { day = month = year = 0; } // очистить
    bool is_correct(); //проверка на правильность
    void getsystemdate(); //получить системную дату
    void getrandomdate(); //получить случайную дату
    string tostr(string & s); //получить строку с датой в строку s без символа новой строки
    string tostr();  //возвращает строку с датой без символа новой строки в конце
    bool setday(int d);  //назначить день, здесь и далее, если операция прошла успешно, то возвращается true
    bool setmonth(int m); //назначить месяц
    bool setyear(int y); //назначить год
    bool setdate(int d, int m, int y); // назначить дату
    int getday() { return day;} //получить дату
    int getmonth() { return month;} //получить месяц
    int getyear() { return year;} //получить год
    void display(); //вывести на экран
    void nextday(); //на день вперед
    void nextweek(); // на неделю вперед
    void nextmonth(); // на месяц вперед
    void nextyear() { year++; } // на год вперед
    void lastday(); // на день назад
    void lastweek(); //на неделю назад
    void lastmonth(); // на месяц назад
    void lastyear() { year--; } //на год назад
    bool operator== (const Date & a) {return ((day==a.day) && (month==a.month) && (year == a.year));}
    bool operator!= (const Date & a) { return !(*this==a); }
    bool operator> (const Date & a);
    bool operator<= (const Date & a) { return !(*this>a); }
    bool operator< (const Date & a);
    bool operator>= (const Date & a) { return !(*this<a); }
    Date operator++ (); //на один день вперед
    Date operator++ (int i);
    Date operator-- (); //на один день назад
    Date operator-- (int i);
    friend ostream & operator<< (ostream & os, const Date & a); //вывод даты
    friend istream & operator>> (istream & is, Date & a); //ввод даты
    friend Date operator+ (int arg, Date & a); // на arg дней вперед
    friend Date operator+ (Date & a, int arg);
    friend Date operator- ( Date & a, int arg); // на arg дней назад
    friend Date operator+= (Date & a, int arg);
    friend Date operator-= (Date & a, int arg);
};
 
Date::Date (string s)
{
    if (s == "system")
        getsystemdate();
    else if (s == "random")
        getrandomdate();
    else
        clear();
}
Date::Date(int d, int m, int y)
{
    day = d;
    month = m;
    year = y;
    if (!is_correct())
        clear();
}
 
bool Date::is_correct ()
{
    bool b = true;
    try
        {
        switch (day) {
            case 29:
            if ((year % 4 != 0) && (month == 2))
                throw Exeption('d',day);
            break;
            case 30:
            if (month == 2)
                throw Exeption('d',day);
            break;
            case 31:
            if ((month == 2) || (month == 4) || (month == 6) || (month == 9) || (month == 11))
                throw Exeption('d',day);
            break;
            default:
            if ((day < 1) || (day > 31))
                throw Exeption('d', day);
            break;
        }
    }
    catch (Exeption e)
    {
        e.writeexept();
        b = false;
    }
    catch (...)
    {
        Exeption e('0');
        e.writeexept();
        b = false;
    }
    try
    {
    if ((month < 1) || (month > 12))
        throw Exeption('m', month);
    }
        catch (Exeption e)
    {
        e.writeexept();
        b = false;
    }
    catch (...)
    {
        Exeption e('0');
        e.writeexept();
        b = false;
    }
    try
    {
    if (year < 1)
        throw Exeption('y', year);
    }
    catch (Exeption e)
    {
        e.writeexept();
        b = false;
    }
    catch (...)
    {
        Exeption e('0');
        e.writeexept();
        b = false;
    }
    return b;
}
 
void Date::getsystemdate()
{
    time_t t;
    time(&t);
    auto a = gmtime(&t);
    day = a->tm_mday;
    month = 1 + a->tm_mon;
    year = 1900 + a->tm_year;
}
 
void Date::getrandomdate()
{
    srand(time(0));
    year = rand() % 2200 + 1;
    month = rand() % 12 + 1;
    if ((month == 1) || (month == 3) || (month == 5) || (month == 7) || (month == 8) || (month == 10) || (month == 12))
        day = rand() % 31 + 1;
    else if ((month == 2) && (year % 4 == 0))
        day = rand() % 29 + 1;
    else if (month == 2)
        day = rand() % 28 + 1;
    else
        day = rand() % 30 + 1;
}
 
string Date::tostr(string & s)
{
    ostringstream os;
    os.fill('0');
    os << setw(2) << day << "." << setw(2) << month << "." << setw(4) << year;
    s = os.str();
    return s;
}
 
string Date::tostr()
{
    string s;
    return tostr(s);
}
 
bool Date::setday(int d)
{
    int temp = day;
    day = d;
    if (is_correct())
        return true;
    else
        day = temp;
    return false;
}
 
bool Date::setmonth(int m)
{
    int temp = month;
    month = m;
    if (is_correct())
        return true;
    else
        month = temp;
    return false;
}
 
bool Date::setyear(int y)
{
    int temp = year;
    year = y;
    if (is_correct())
        return true;
    else
        year = temp;
    return false;
}
 
bool Date::setdate(int d, int m, int y)
{
    int tempd = day, tempm = month, tempy = year;
    day = d;
    month = m;
    year = y;
    if (is_correct())
        return true;
    else
        day = tempd;
    month = tempm;
    year = tempy;
    return false;
}
 
void Date::display()
{
    cout <<  tostr() << endl;
}
 
void Date::nextday()
{
    switch (day)
    {
        case 28:
        if ((month == 2) && (year % 4 != 0))
            {
                day = 1;
                month++;
            }
        else
            day++;
        break;
        case 29:
        if (month == 2)
            {
            day = 1;
            month++;
            }
        else
            day++;
        break;
        case 30:
        if ((month == 4) || (month == 6) || (month == 9) || (month == 11))
            {
                day = 1;
                month++;
            }
        else
            day++;
        break;
        case 31:
        day = 1;
        if (month == 12)
            {
                year++;
                month = 1;
            }
        else
            month++;
        break;
        default:
            day++;
        break;
    }
}
 
void Date::nextweek()
{
    for (int i=0;i<7;i++)
           nextday();
}
 
void Date::nextmonth()
{
    if (month == 12)
       {
           month = 1;
           year++;
       }
    else
        month++;
}
 
void Date::lastday()
{
    if (day == 1)
        {
            switch (month)
            {
                case 1:
                day = 31;
                year--;
                month = 12;
                break;
                case 2:
                case 4:
                case 6:
                case 8:
                case 9:
                case 11:
                day = 31;
                month--;
                break;
                case 3:
                if (year % 4 == 0)
                    day = 29;
                else
                    day = 28;
                month--;
                break;
                default:
                day = 30;
                month--;
                break;
            }
        }
    else
        day--;
    is_correct();
}
 
void Date::lastweek()
{
    for (int i = 0; i < 7; i++)
        lastday();
    is_correct();
}
 
void Date::lastmonth()
{
    if (month == 1)
         {
            month = 12;
            year--;
        }
    else
        month--;
    is_correct();
}
 
bool Date::operator>(const Date & a)
{
    if (year>a.year)
        return true;
    else if (year==a.year)
                if (month>a.month)
                    return true;
                else if (month==a.month)
                            if (day>a.day)
                                return true;
    return false;
}
 
bool Date::operator< (const Date & a)
{
    if ( year < a.year)
        return true;
    else if (year == a.year)
                if (month < a.month)
                    return true;
                else if (month == a.month)
                            if (day < a.day)
                                return true;
    return false;
}
 
Date Date::operator++()
{
    nextday();
    return *this;
}
 
Date Date::operator++ (int i)
{
    nextday();
    return *this;
}
 
Date Date::operator-- ()
{
    lastday();
    is_correct();
    return *this;
}
 
Date Date::operator-- (int i)
{
    lastday();
    is_correct();
    return *this;
}
 
 
ostream & operator<< (ostream & os, Date & a)
{
    os << a.tostr() << endl;
    return os;
}
 
istream & operator>> (istream & is, Date & a)
{
    int d,m,y;
    do {
        do {
            cout << "Введите день: ";
            cin >> d;
            if (!cin)
            {
                cin.clear();
                while (cin.get() != '\n');
                cout << "Повторите ввод!" << endl;
                continue;
            }
        } while (!a.setday(d));
        do {
            cout << "Введите месяц: ";
            cin >> m;
            if (!cin)
            {
                cin.clear();
                while (cin.get() != '\n');
                cout << "Повторите ввод!" << endl;
                continue;
            }
        } while (!a.setmonth(m));
        do {
            cout << "Введите год: ";
            cin >> y;
            if (!cin)
            {
                cin.clear();
                while (cin.get() != '\n');
                cout << "Повторите ввод!" << endl;
                continue;
            }
        } while (!a.setyear(y));
    } while (!a.is_correct());
    return is;
}
 
Date operator+ (int arg, Date & a)
{
    for (register int i = 0; i < arg; i++)
        a.nextday();
    return a;
}
 
Date operator+ (Date & a, int arg)
{
    for (register int i = 0; i < arg; i++)
        a.nextday();
    return a;
}
 
Date operator- ( Date & a, int arg)
{
    for (register int i = 0; i < arg; i++)
        a.lastday();
    a.is_correct();
    return a;
}
 
Date operator+= (Date & a, int arg)
{
    for (register int i = 0; i < arg; i++)
        a.nextday();
    return a;
}
 
Date operator-= (Date & a, int arg)
{
    for (register int i = 0; i < arg; i++)
        a.lastday();
        a.is_correct();
    return a;
}
// Made by shilko2013

#include <iostream>
#include <vector>
#include <map>
 
 
typedef std::vector<std::vector<double> > TMatrixOfDouble;
typedef void* TLayer;
typedef std::vector<TLayer> TLayers;
 
 
class Parameter {
    
public:
    
    TLayers layers;
    
    static std::map<TLayer, TMatrixOfDouble> calling;
 
   
    Parameter(TLayers info) {
        
        layers.push_back(info[0]);
        
        //calling[info[0]] = TMatrixOfDouble(info.begin() + 1, info.end());
    }
};
 
 
int main()
{
    std::cout << "Hello, world!\n";
}