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

    Теперь полный листинг 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).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 { // Нейрон 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 =", " == == public Double predict == == weight1=" + String.valueOf(app.neurobiasweight [nnum][1])); Log.i("== TRAIN =", " == == public Double predict == == 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(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 =", " == == ПОСЛЕ СИГМОИДА == == Util.sigmoid(preActivation)=" + String.valueOf(output) + " <-- Neuron Output"); normalize(output); // Для организации обратной связи correctinput(); // Если не чётное, то вычесть из Input Log.i("== TRAIN =", " == ===================================================================== == "); return output; } 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 } public static double sigmoidDeriv(double in){ double sigmoid = Util.sigmoid(in); return sigmoid * (1 - in); } // (1 / (1 + Math.exp(-in)))* (1 - in) } // Util class
    
    Теперь мы делаем два прямых пересчета
    
    
     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));
    
    Первый пересчёт
    
    Double Te = network1000.predict(data[0][0],data[0][1]);
    
    и второй пересчёт
    
    ////Te = network1000.predict(data[0][0],data[0][1]);
    
    или
    
    Te = network1000.predict(120,67);
    
    Почему испробовано два варианта второго прямого рачёта?
    Потому, что в 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 >>
    

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