Бесплатные курсовые

    Простой нейронный PRNG на JAVA
    Создадим простую нейронную сеть для генерирования псевдослучайных чисел.
    Пока мы будем использовать простейший вариант генерирования. Будем корректировать только входные данные нейронной сети (мастер-ключ) генератора.
    Веса и смещения нейронов пока будут постоянными.
    
    Посмотрим, что делается в нейроне
    
     public double compute(double input1, double input2, int nnum){ // Вычисляем выходные данные нейрона nnum double preActivation = (this.weight1 * input1) + (this.weight2 * input2) + this.bias; // Вес 1*Вход 1 + Вес 2*Вход 2 * Смещение // Пропускаем данные preActivation - через Сигмоид double output = Util.sigmoid(preActivation); // Диапазон значений output - 0-1 return output; }
    Здесь return output возвращает выходное значение нейрона - то число, которое мы будем использовать для корректирования мастер-ключа (входных данных нейронной сети) - (1) и для вычисления битов псевдослучайного числа - (2).
    Для (1) и (2) используем простейшие приёмы для демонстрации. Потом напишем более интересные методы.
    

    App.java
    
    package com.example.neuroprng1; import android.util.Log; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Random; // Часть 2. // Обучение нейронной сети пока не используется, поэтому вычисления только в прямом направлении // Дата-сет для тренировки с правильными ответами пока тоже не нужен // Среднеквадратичная ошибка так же не подсчитывается. Всё это будет использовано потом // Фактически, это ещё не нейронная сеть, а прототип //-------------------------------------------------------------- public class App { public static Integer neuronnum = 0; // Номер Нейрона public static void main( String[] args ) { //App app = new App(); //app.trainAndPredict(); // Начинает работать с этого - заполняем массивы данными и ответами } public void trainAndPredict() { Integer data [][] = new Integer[4][4]; // Двумерный массив ВХОДНЫХ ДАННЫХ (мпстер-ключ) По 4 значения input1 и input2 // Заполняем значениями // 4 пары значений data[0][0] = 115; // input1 data[0][1] = 66; // input2 data[1][0] = 175; // input1 data[1][1] = 78; // input2 data[2][0] = 205; // input1 data[2][1] = 72; // input2 data[3][0] = 120; // input1 data[3][1] = 67; // input2 // Ответы для заданных выше пар входных значений // Пока в нейронной сети не написано обучение, они нам не нужны Double answers [] = new Double[4]; // Создаем сеть из 6 нейронов, задаем входные значения и пишем на экран результат - переменная Te Network network1000 = new Network(); // Вызов класса Network, метод predict - создаем сеть Network1000 Double Te = network1000.predict(data[0][0],data[0][1]); // predict(Рост,Вес) - Return Double Log.i("== NNETWORK Output =", " == == network1000.predict == == Double Te=" + String.valueOf(Te)); } } // App //-------------------------------------------------------------------- class Network { // Вызывается из класса App int epochs = 0; //1000; Double learnFactor = null; App nrn = new App(); // Экземпляр класса List<Neuron> neurons = Arrays.asList( // Расширяемый список нейронов из класса Neuron new Neuron(), new Neuron(), new Neuron(), // Входной уровень new Neuron(), new Neuron(), // Скрытый уровень new Neuron()); // Выходной уровень //----- ПРЯМОЕ РАСПРОСТРАНЕНИЕ -------------------------------- // Фактически, все вычисления нейронной сети в прямом направлении // // Два входных сигнала input1 и input2 подаются в первые три нейрона 0,1 и 2, выходные данные // которых затем передаются по конвейеру в нейроны 3 и 4, которые, // в свою очередь, передаются в выходной нейрон 5. Выход нейрона 5 возвращается - return neurons.get(5).compute // Этот процесс известен как прямая связь // Специально для упрощения понимания здесь введены НОМЕРА НЕЙРОНОВ nnum public Double predict(Integer input1, Integer input2){ // На вход подавать input1 и input2 Log.i("== NCOMPUTE =", " == == predict Neuron(input1, input2) == == input1=" + String.valueOf(input1)); Log.i("== NCOMPUTE =", " == == predict Neuron(input1, input2) == == input2=" + String.valueOf(input2)); Log.i("== NCOMPUTE =", " == ===================================================================== == "); return neurons.get(5).compute( // Где neurons - это List<Neuron> neurons = Arrays.asList(new Neuron(), new Neuron(), new Neuron(),new Neuron(), new Neuron(),new Neuron()); neurons.get(4).compute( // Compute - начальная активация. class Neuron neurons.get(2).compute(input1, input2, 2), // compute - здесь - СИГМОИД - Util.sigmoid(preActivation) neurons.get(1).compute(input1, input2, 1),4 // compute - здесь - СИГМОИД - Util.sigmoid(preActivation) ), neurons.get(3).compute( neurons.get(1).compute(input1, input2,1), // Получить из списка neurons ПЕРВЫЙ элемент (нейрон) с входными значениями input1, input2 neurons.get(0).compute(input1, input2,0),3 // compute - здесь - СИГМОИД - Util.sigmoid(preActivation) ),5 ); } } // Network //-------------------------------------------------------------------- class Neuron { // Нейрон https://belsap.com/2019/03/%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5-%D1%81%D0%B5%D1%82%D0%B8-%D0%B4%D0%BB%D1%8F-%D0%BD%D0%B0%D1%87%D0%B8%D0%BD%D0%B0%D1%8E%D1%89%D0%B8%D1%85/ //----- Инициализация нейрона -------------------------------- // Нейрон с двумя входами, поэтому два ВЕСА, одно смещение и некая функция активации private Double bias = randomnextDouble(-1, 1); // Bias - смещение public Double weight1 = randomnextDouble(-1, 1); // Вес 1 private Double weight2 = randomnextDouble(-1, 1); // Вес 2 //----- Функция активации нейрона. Самая простая ------------- // Функция активации - от RND заполняется Вес1, Вес2 и смещение для каждого нейрона public double randomnextDouble(double start, double end) { // Random DOUBLE double random = new Random().nextInt(); double result = start + (random * (end - start)); return (result); } //----- Вычисляем выходные данные нейрона -------------------------- // На вход подаются два сигнала input1 и input2 и номер нейрона // Когда мы вычисляем выходные данные нейрона, мы следуем алгоритму: // умножаем каждый входной сигнал на его вес плюс // смещение: вход1 * вес1 + вход2 * вес2 + смещение . Это дает нам необработанные // вычисления (т. е. preActivation), которые мы запускаем через функцию активации. // В этом случае мы используем функцию активации Sigmoid , которая сжимает значения // в диапазон от 0 до 1. public double compute(double input1, double input2, int nnum){ // Вычисляем выходные данные нейрона nnum Log.i("== TRAIN =", " == == Neuron Number == == " + String.valueOf(nnum)); Log.i("== TRAIN =", " == == public Double predict == == weight1=" + String.valueOf(weight1)); Log.i("== TRAIN =", " == == public Double predict == == weight2=" + String.valueOf(weight2)); Log.i("== TRAIN =", " == == public Double predict == == bias=" + String.valueOf(bias)); // preActivation - необработанные данные нейрона (от фонаря) - до Сигмоида double preActivation = (this.weight1 * input1) + (this.weight2 * input2) + this.bias; // Вес 1*Вход 1 + Вес 2*Вход 2 * Смещение Log.i("== TRAIN =", " == == public Double predict == == input1=" + String.valueOf(input1) + " input2=" + String.valueOf(input2)); Log.i("== TRAIN =", " == == public Double predict == == weight1 * input1=" + String.valueOf(this.weight1 * input1)); Log.i("== TRAIN =", " == == public Double predict == == weight2 * input2=" + String.valueOf(this.weight2 * input2)); // Пропускаем необработанные данные preActivation - через Сигмоид double output = Util.sigmoid(preActivation); // Диапазон значений output - // [0,1]. Класс Util функция активации(метод) sigmoid(preActivation) // Здесь preActivation - необработанные вычисления - умножанные каждый входной сигнал на его вес плюс смещение: // вход1 * вес1 + вход2 * вес2 + смещение Log.i("== TRAIN =", " == == public Double predict == == Util.sigmoid(preActivation)=" + String.valueOf(output) + " <-- Neuron Output"); Log.i("== TRAIN =", " == ===================================================================== == "); return output; } } // Neuron //----- Функция активации - СИГМОИД ---------------------------- class Util { public static double sigmoid(double in){ // Функция активации - СИГМОИД. Диапазон значений [0,1] // Здесь in - это preActivation = вход1 * вес1 + вход2 * вес2 + смещение return 1 / (1 + Math.exp(-in)); // Сигмоид. Сжимает значения в диапазон от 0 до 1 } public static double sigmoidDeriv(double in){ double sigmoid = Util.sigmoid(in); return sigmoid * (1 - in); } } // Util class
    
     Здесь выполняется только один проход в прямом направлении. Получаем результаты на выходе каждого нейрона и на выходе нейронной сети (нейрон 5)
    Нормализуем выходные значения каждого нейрона. Входные данные у нас - Integer data [][]. Приведем выходные данные с каждого нейрона к виду INTEGER. Напишем отдельный метод
    
    Читаем ДАЛЕЕ >>