Neural Network PRNG

    Теперь полный листинг 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 Double neurobiasweight [][] = new Double[6][3]; // Массив весов для нейронов [weight1][weight2] public static Integer deltaweight1 = 0; // Корректировка weight1 через обратную связь public static Integer deltaweight2 = 0; // Корректировка weight2 через обратную связь public static Integer data [][] = new Integer[4][4]; // Двумерный массив ВХОДНЫХ ДАННЫХ (мпстер-ключ) По 4 значения input1 и input2 public static Integer neuronnum = 0; // Номер Нейрона public static void main( String[] args ) { //App app = new App(); //app.trainAndPredict(); // Начинает работать с этого - заполняем массивы данными и ответами } public void trainAndPredict() { // Заполняем значениями // 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 // Зададим статические значение веса для каждого нейрона. Для повторяемости результатов в разных экземплярах приложения neurobiasweight [0][1] = 0.2921867401328437; // Нейрон 0 вес 1 neurobiasweight [0][2] = 0.6753277674739143; // Нейрон 0 вес 2 neurobiasweight [1][1] = 0.638204802420569; // Нейрон 1 вес 1 neurobiasweight [1][2] = 0.8256511687684168; // Нейрон 1 вес 2 neurobiasweight [2][1] = 0.9570075176019762; // Нейрон 2 вес 1 neurobiasweight [2][2] = 0.39564267118987084; // Нейрон 2 вес 2 neurobiasweight [3][1] = 0.2463716717762578; // Нейрон 3 вес 1 neurobiasweight [3][2] = 0.8565685160656823; // Нейрон 3 вес 2 neurobiasweight [4][1] = 0.8529762783770741; // Нейрон 4 вес 1 neurobiasweight [4][2] = 0.7818602822337215; // Нейрон 4 вес 2 neurobiasweight [5][1] = 0.36204206369478864; // Нейрон 5 вес 1 neurobiasweight [5][2] = 0.6998272379065108; // Нейрон 5 вес 2 // В этот же массив запишем смещение bias neurobiasweight [0][0] = 0.6372796901523922; // Нейрон 0 смещение bias neurobiasweight [1][0] = 0.24087856177175287; // Нейрон 1 смещение bias neurobiasweight [2][0] = 0.20294311087331438; // Нейрон 2 смещение bias neurobiasweight [3][0] = 0.6005802079109952; // Нейрон 3 смещение bias neurobiasweight [4][0] = 0.24210376151411686; // Нейрон 4 смещение bias neurobiasweight [5][0] = 0.3291532687509765; // Нейрон 5 смещение bias // Ответы для заданных выше пар входных значений // Пока в нейронной сети не написано обучение, они нам не нужны 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)); Log.i("== NNETWORK Output =", " == == ВТОРОЕ ВЫЧИСЛЕНИЕ С откорректированными Input1 и Input2 == == " ); Log.i("== NNETWORK Output =", " == == data[0][0] и data[0][1] Input1=" + String.valueOf(data[0][0]) + " и Input2=" + String.valueOf(data[0][1])); ////Te = network1000.predict(data[0][0],data[0][1]); // predict(Рост,Вес) - Return Double Te = network1000.predict(120,67); // 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).computeOOS( // Где neurons - это List<Neuron> neurons = Arrays.asList(new Neuron(), new Neuron(), new Neuron(),new Neuron(), new Neuron(),new Neuron()); neurons.get(4).computeOOS( // Compute - начальная активация. class Neuron neurons.get(2).computeOOS(input1, input2, 2), // compute - здесь - СИГМОИД - Util.sigmoid(preActivation) neurons.get(1).computeOOS(input1, input2, 1),4 // compute - здесь - СИГМОИД - Util.sigmoid(preActivation) ), neurons.get(3).computeOOS( neurons.get(1).computeOOS(input1, input2,1), // Получить из списка neurons ПЕРВЫЙ элемент (нейрон) с входными значениями input1, input2 neurons.get(0).computeOOS(input1, input2,0),3 // compute - здесь - СИГМОИД - Util.sigmoid(preActivation) ),5 ); } } // Network //-------------------------------------------------------------------- class Neuron { // Нейрон App app = new App(); // Экземпляр класса //----- Инициализация нейрона -------------------------------- // Нейрон с двумя входами, поэтому два ВЕСА, одно смещение и некая функция активации private Double bias = randomnextDouble(0.1, 1); // Bias - смещение public Double weight1 = randomnextDouble(0.1, 1); // Вес 1 private Double weight2 = randomnextDouble(0.1, 1); // Вес 2 //----- Функция активации нейрона. Самая простая ------------- // Функция активации - от RND заполняется Вес1, Вес2 и смещение для каждого нейрона public double randomnextDouble(double start, double end) { // Random DOUBLE double random = new Random().nextDouble(); double result = start + (random * (end - start)); Log.i("== RANDOMNEXTDOUBLE =", " == == " + String.valueOf(result)); return Math.abs(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)); Log.i("== TRAIN =", " == == app.neurobiasweight ["+ nnum +"][1] == == weight1=" + String.valueOf(app.neurobiasweight [nnum][1])); Log.i("== TRAIN =", " == == app.neurobiasweight ["+ nnum +"][2] == == weight2=" + String.valueOf(app.neurobiasweight [nnum][2])); Log.i("== TRAIN =", " == == public Double predict == == bias=" + String.valueOf(app.neurobiasweight [nnum][0])); // preActivation - необработанные данные нейрона (от фонаря) - до Сигмоида ////==== double preActivation = (this.weight1 * input1) + (this.weight2 * input2) + this.bias; // Вес 1*Вход 1 + Вес 2*Вход 2 * Смещение Log.i("== STATICWEIGHT =", " == == app.neurobiasweight == == app.neurobiasweight ["+nnum+"][0]=" + String.valueOf(app.neurobiasweight [nnum][0])); double preActivation = (app.neurobiasweight [nnum][1] * input1) + (app.neurobiasweight [nnum][2] * input2) + app.neurobiasweight [nnum][0]; // Вес 1*Вход 1 + Вес 2*Вход 2 * Смещение Log.i("== TRAIN =", " == == ПЕРЕД СИГМОИДОМ == == preActivation=" + String.valueOf(preActivation)); Log.i("== TRAIN =", " == == public Double predict == == input1=" + String.valueOf(input1) + " input2=" + String.valueOf(input2)); Log.i("== TRAIN =", " == == public Double predict == == weight1 * input1=" + String.valueOf(app.neurobiasweight [nnum][1] * input1)); Log.i("== TRAIN =", " == == public Double predict == == weight2 * input2=" + String.valueOf(app.neurobiasweight [nnum][2] * input2)); // Пропускаем необработанные данные preActivation - через Сигмоид double output = Util.sigmoid(preActivation); // Диапазон значений output - // [0,1]. Класс Util функция активации(метод) sigmoid(preActivation) // Здесь preActivation - необработанные вычисления - умножанные каждый входной сигнал на его вес плюс смещение: // вход1 * вес1 + вход2 * вес2 + смещение Log.i("== TRAIN =", " == == ПОСЛЕ СИГМОИДА == == Util.sigmoid(preActivation)=" + String.valueOf(output) + " <-- Neuron Output"); normalize(output); // Для организации обратной связи correctinput(); // Если не чётное, то вычесть из Input Log.i("== TRAIN =", " == ===================================================================== == "); return output; } public double computeOOS(double input1, double input2, int nnum){ // Обратная связь для нейрона // Если output нейрона №num равен 1 или 0, то корректировать вес1 и вес2 этого нейрона while (compute(input1, input2,nnum) == 1.0) {// Вызов стандартного COMPUTE app.neurobiasweight [nnum][1] -= 0.021E1; // Вес1 нейрона №num app.neurobiasweight [nnum][2] -= 0.027E1; // Вес2 нейрона №num Log.i("== TRAIN =", " ==>>>===================================================================== == "); } while (compute(input1, input2,nnum) == 0.0) {// Вызов стандартного COMPUTE app.neurobiasweight [nnum][1] += 0.027E1; // Вес1 нейрона №num app.neurobiasweight [nnum][2] += 0.021E1; // Вес2 нейрона №num Log.i("== TRAIN =", " ==>>> >>>===================================================================== == "); } double output = compute(input1, input2,nnum); Log.i("== TRAIN =", " ==>>> >>> >>>===================================================================== == "); return output; } // computeOOS public Integer normalize(double neuroutput) { // Проверить выходное значение нейрона, что оно не 0 и не 1 Integer result= 0; if (neuroutput != 0){ if (neuroutput !=1) { String str = String.valueOf(neuroutput); // Преобразовать Double в String String substr = str.substring(7, 8); // Одна цифра result = Integer.valueOf(substr); // Одноразрядный Integer app.deltaweight1 = Integer.valueOf(str.substring(7, 8)); // Одноразрядный Integer для корректировки weight1 app.deltaweight2 = Integer.valueOf(str.substring(8, 9)); // Одноразрядный Integer для корректировки weight2 Log.i("== NORMALIZE =", " == == Integer.valueOf(substr) == == substr=" + str.substring(7, 8)); Log.i("== NORMALIZE =", " == == Integer.valueOf(substr) == == substr=" + str.substring(8, 9)); } } return (null); } public Integer correctinput() { // Если deltaweight - чётное, то с плюсом, если не чётное,то с минусом if (app.deltaweight1 % 2 != 0){ // Число не чётное app.deltaweight1 *= -1; // Взять со знаком минус } if (app.deltaweight2 % 2 != 0){ // Число не чётное app.deltaweight2 *= -1; // Взять со знаком минус } app.data[0][0] += app.deltaweight1; app.data[0][1] += app.deltaweight2; return (null); } } // 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 } // (1 / (1 + Math.exp(-in)))* (1 - in) } // Util class
    
    В принципе, проблема решена. Веса нейронов корректируются. При разных входных данных Input1 и Input2 получаем разные выходные значения нейронной сети.
    И даже реализована обратная связь по входу нейронной сети.
    
    Но это ещё не всё. Мы проверили работоспособность всего на двух входных значениях. Вполне возможно, что найдутся такие входные значения, при которых сеть работать не будет.
    Поэтому займёмся инспекцией JAVA крда, уберём лишние Log сообщения (которые уже не несут полезности).
    
    
    Читаем ДАЛЕЕ >>
    

Neural PRNG

    
    
    
    Valery Shmelev Android Developer
    
      Нейронная Сеть на JAVA >>  
    
    Полный Android JAVA проект SimpleNNeuron. Проект простейшей Нейронной Сети на Android JAVA (Часть 1). Проект компилируется в Android Studio и работает. Выводит данные в Log i.
    Это проект начального прототипа нейронной сети (работающая заготовка, шаблон) из 6 нейронов. Прототип создает нейронную сеть, инициализирует ее, показывается передача данных из слоя в слой, использование весов и смещения. Обучение нейронной сети не используется для упрощения проекта на этом этапе. В части 2 проекта реализована обратная связь по входу для увеличения нелинейности.
    Проект создан для начинающих программистов. Использован максимально простой JAVA код. Много комментариев.
    
      JAVA ПРОЕКТ PRNG 1024 bit >>  
    Без нейронной сети
    
    Курсовой проект Полный Android JAVA проект весьма качественного генератора псевдослучайных чисел большой размерности 1024 бит BigIntPRNG1024bit. Компилируется, инсталлируестся, работает В проекте есть много комментариев и LOG сообщений. JAVA код проекта не оптимизировался, не "причёсывался" и соответствует студенческому проекту. В проекте есть файлы README.txt и Android_Java_PRNG.docx с кратким описанием. Для работы приложения необходимо ввести в самое верхнее текстовое поле английский текст и/или цифры больше 100 знаков - исходные данные для генерирования (мастер-ключ). В приложении реализовано несколько уровней последовательной генерации с использованием алгоритма Blum-Blum-Shub. ZIP архив - 24 249 699 байт.
    Приложение генерирует массив из 50 случайных чисел размера 1024 бит. Первое показывается на экране. Весь массив можно поместить в стандартный буфер обмена смартфона. Приложение работает с числами формата Big Int и легко может быть модернизировано для генерации чисел размерности 2048 или 4096 бит и больше.
    Это хороший курсовой проект, который будет интересен преподавателю. В принципе, качество генерируемых чтсел с огромным запасом достаточно для эффективного XOR шифрования деловой переписки, хрпнения паролей, номеров телефонов и т.д. <
    
    Neuro >>
    

<<<< Предыдущая  Следующая >>>>