Создание модели

нейросеть.создать()

Создаёт пустую модель нейронной сети последовательного типа (Sequential). К ней можно последовательно добавлять слои.

₽модель = нейросеть.создать();

 Добавление слоя

модель.добавитьСлой(конфигурация)

Добавляет слой к модели. Конфигурация передаётся в виде объекта с параметрами.

₽модель.добавитьСлой({
    "тип": "плотный",
    "входы": 20,
    "выходы": 1,
    "активация": "sigmoid"
});

 Компиляция модели

модель.компилировать(оптимизатор, функцияПотерь)

Настраивает модель для обучения. Указывает оптимизатор и функцию потерь.

₽модель.компилировать(
    { "тип": "sgd", "скорость": 0.5 },
    { "тип": "crossentropy" }
);

 Обучение модели

модель.обучить(входы, метки, эпохи, размерПакета [, колбэк])

Запускает процесс обучения нейросети на предоставленных данных.

₽печатать = функция(₽эпоха, ₽потери) {
    если (₽эпоха % 100 == 0) {
        вывести("Эпоха ", ₽эпоха, ": потери = ", ₽потери);
    }
};
₽модель.обучить(₽последовательности, ₽метки, 1000, 8, ₽печатать);

 Предсказание

модель.предсказать(вход)

Выполняет прямой проход по модели для одного входного вектора и возвращает результат.

₽предсказание = ₽модель.предсказать(₽индексы);
₽класс = 0;
если (₽предсказание[0] > 0.5) { ₽класс = 1; }

 Типы слоёв

• плотный (Dense) — полносвязный слой. Каждый нейрон соединён со всеми нейронами предыдущего слоя.

В будущем планируется добавление слоёв: сверточный, рекуррентный, lstm и др.

 Функции активации

• sigmoid — сигмоида: σ(x) = 1 / (1 + e-x). Используется для бинарной классификации (выход от 0 до 1).
• relu — ReLU(x) = max(0, x). Часто используется в скрытых слоях.
• tanh — гиперболический тангенс: tanh(x) = (ex - e-x) / (ex + e-x). Выход от -1 до 1.
• linear — линейная активация: f(x) = x. Используется для регрессии.

 Оптимизаторы

• sgd — стохастический градиентный спуск (Stochastic Gradient Descent). Параметр скорость (learning rate) регулирует шаг обновления весов.

 Функции потерь

• crossentropy — бинарная кросс-энтропия. Используется для бинарной классификации.

 Полный пример: бинарная классификация текстов

Ниже приведён полный скрипт, демонстрирующий создание, обучение и использование нейронной сети для классификации текстовых отзывов на положительные (1) и отрицательные (0).

Скрипт включает:

• Создание небольшого словаря (10 слов) и one-hot кодирование.
• Токенизацию текстов в векторы фиксированной длины (20).
• Построение модели с одним плотным слоем (вход 20 → выход 1, сигмоида).
• Обучение на 20 примерах (1000 эпох, SGD с высокой скоростью).
• Тестирование на новых текстах.

// ============================================================
// Бинарная классификация текстов (один слой)
// ============================================================

₽массивы = массивы;
₽строки = строки;
₽нейросеть = нейросеть;

// Словарь
₽размерСловаря = 10;

// One-hot
₽oneHot = функция(₽индекс) {
    ₽вектор = [];
    для (₽i = 0; ₽i < ₽размерСловаря; ₽i = ₽i + 1) {
        если (₽i == ₽индекс) {
            ₽вектор = ₽массивы.добавить(₽вектор, 1);
        } иначе {
            ₽вектор = ₽массивы.добавить(₽вектор, 0);
        }
    }
    возврат ₽вектор;
};

// Токенизация -> one-hot (длина 20)
₽токенизировать = функция(₽текст) {
    ₽слова = ₽строки.разбить(₽строки.нижний(₽текст), " ");
    ₽результат = [];
    для каждого (₽слово из ₽слова) {
        ₽индекс = 0;
        если (₽слово == "хороший" || ₽слово == "хорошая") { ₽индекс = 0; }
        иначе если (₽слово == "отличный" || ₽слово == "отличная") { ₽индекс = 1; }
        иначе если (₽слово == "прекрасный" || ₽слово == "прекрасная") { ₽индекс = 2; }
        иначе если (₽слово == "плохой" || ₽слово == "плохая") { ₽индекс = 3; }
        иначе если (₽слово == "ужасный" || ₽слово == "ужасная") { ₽индекс = 4; }
        иначе если (₽слово == "фильм") { ₽индекс = 5; }
        иначе если (₽слово == "актёр") { ₽индекс = 6; }
        иначе если (₽слово == "игра") { ₽индекс = 7; }
        иначе если (₽слово == "сценарий") { ₽индекс = 8; }
        иначе если (₽слово == "музыка") { ₽индекс = 9; }
        ₽вектор = ₽oneHot(₽индекс);
        для (₽j = 0; ₽j < ₽размерСловаря; ₽j = ₽j + 1) {
            ₽результат = ₽массивы.добавить(₽результат, ₽вектор[₽j]);
        }
    }
    пока (₽массивы.длина(₽результат) < 20) {
        ₽результат = ₽массивы.добавить(₽результат, 0);
    }
    возврат ₽результат;
};

// Данные
₽тексты = [
    "хороший фильм", "отличный актёр", "прекрасная музыка",
    "хороший актёр", "отличный фильм", "прекрасный фильм",
    "плохой актёр", "ужасный фильм", "плохой сценарий",
    "ужасный актёр", "плохой фильм", "ужасный сценарий",
    "хороший сценарий", "отличная игра", "прекрасный актёр",
    "плохая музыка", "ужасная игра", "хорошая музыка",
    "отличный сценарий", "прекрасная игра"
];
₽метки = [1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1];

₽последовательности = [];
для каждого (₽текст из ₽тексты) {
    ₽последовательности = ₽массивы.добавить(₽последовательности, ₽токенизировать(₽текст));
}

// Модель: ОДИН СЛОЙ (вход 20 → выход 1, сигмоида)
₽модель = ₽нейросеть.создать();
₽модель.добавитьСлой({
    "тип": "плотный",
    "входы": 20,
    "выходы": 1,
    "активация": "sigmoid"
});

// Компиляция: SGD с высокой скоростью + бинарная кросс-энтропия
₽модель.компилировать(
    { "тип": "sgd", "скорость": 0.5 },
    { "тип": "crossentropy" }
);

вывести("Модель создана. Начинаем обучение на 1000 эпох...");

₽печатать = функция(₽эпоха, ₽потери) {
    если (₽эпоха % 100 == 0) {
        вывести("Эпоха ", ₽эпоха, ": потери = ", ₽потери);
    }
};

₽модель.обучить(₽последовательности, ₽метки, 1000, 8, ₽печатать);

вывести("Обучение завершено.");

// Тесты
₽тест1 = "хороший актёр";
₽индексы1 = ₽токенизировать(₽тест1);
₽пред1 = ₽модель.предсказать(₽индексы1);
₽класс1 = 0;
если (₽пред1[0] > 0.5) { ₽класс1 = 1; }
вывести("Текст: '" + ₽тест1 + "' → Предсказание: " + ₽пред1[0] + " (класс: " + ₽класс1 + ")");

₽тест2 = "ужасный актёр";
₽индексы2 = ₽токенизировать(₽тест2);
₽пред2 = ₽модель.предсказать(₽индексы2);
₽класс2 = 0;
если (₽пред2[0] > 0.5) { ₽класс2 = 1; }
вывести("Текст: '" + ₽тест2 + "' → Предсказание: " + ₽пред2[0] + " (класс: " + ₽класс2 + ")");

₽тест3 = "прекрасная игра";
₽индексы3 = ₽токенизировать(₽тест3);
₽пред3 = ₽модель.предсказать(₽индексы3);
₽класс3 = 0;
если (₽пред3[0] > 0.5) { ₽класс3 = 1; }
вывести("Текст: '" + ₽тест3 + "' → Предсказание: " + ₽пред3[0] + " (класс: " + ₽класс3 + ")");

₽тест4 = "плохой фильм";
₽индексы4 = ₽токенизировать(₽тест4);
₽пред4 = ₽модель.предсказать(₽индексы4);
₽класс4 = 0;
если (₽пред4[0] > 0.5) { ₽класс4 = 1; }
вывести("Текст: '" + ₽тест4 + "' → Предсказание: " + ₽пред4[0] + " (класс: " + ₽класс4 + ")");

вывести("Тест завершён.");