├── README.md └── neuralmaster ├── 3 ├── Neuron_no_b.ipynb └── Neuron_yes_b.ipynb ├── 4 └── Neuron_yes_b.ipynb ├── 5 ├── Neuron_log_and.ipynb ├── Neuron_log_and_sigma.ipynb ├── Neuron_log_or.ipynb ├── Neuron_no_or.ipynb ├── number_bin │ ├── Neuron_number_bin0.ipynb │ └── dataset │ │ ├── Data_test.csv │ │ └── Data_train.csv └── number_sigma │ ├── Neuron_number_sigma.ipynb │ └── dataset │ ├── Data_test.csv │ └── Data_train.csv ├── 6 ├── Neuron_2_number_sigma.ipynb └── dataset │ ├── Data_test.csv │ └── Data_train.csv └── 7_8 ├── MNIST ├── 7Recognize_MNIST.ipynb ├── 8Conv_maxpool_.ipynb ├── 8Convolution_algorithms.ipynb ├── 8Recognize_MNIST_RELU_softmax.ipynb ├── 8conv_distribution_error.ipynb ├── 8conv_no_distribution_error.ipynb ├── MNIST_dataset.zip └── my_image │ ├── _my_0.png │ ├── _my_1.png │ ├── _my_2.png │ ├── _my_3.png │ ├── _my_4.png │ ├── _my_5.png │ ├── _my_6.png │ ├── _my_7.png │ └── _my_8.png ├── Neuron_no_or.ipynb ├── Neuron_no_or_1out.ipynb ├── Neuron_no_or_2_4_1out.ipynb ├── Neuron_no_or_2out.ipynb ├── Neuron_or_1out.ipynb ├── Neuronet_RELU_apr_b_70hidden.ipynb ├── Neuronet_RELU_apr_b_7hidden.ipynb ├── Neuronet_lin_apr_b_6hidden.ipynb ├── Neuronet_sigma_apr_b_6hidden.ipynb ├── Neuronet_tan_apr_b_3hidden.ipynb ├── Neuronet_tan_apr_b_6hidden.ipynb └── dataset ├── Data_or.csv ├── Data_sin.csv ├── Data_sin_1.csv ├── Data_sin_x.csv ├── Data_sin_y.csv ├── Data_test.csv └── Data_train.csv /README.md: -------------------------------------------------------------------------------- 1 | # neuralmaster 2 | 1_Repository 3 | -------------------------------------------------------------------------------- /neuralmaster/3/Neuron_no_b.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 8, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "Начальная прямая: 0.4 * X\n", 13 | "Готовая прямая: y = 2.0562708725692196 * X\n" 14 | ] 15 | } 16 | ], 17 | "source": [ 18 | "# Инициализируем любым числом коэффициент крутизны наклона прямой\n", 19 | "A = 0.4\n", 20 | "A_vis = A # Запоминаем начальное значение крутизны наклона\n", 21 | "# Вывод данных начальной прямой\n", 22 | "print('Начальная прямая: ', A, '* X')\n", 23 | "\n", 24 | "# Скорость обучения\n", 25 | "lr = 0.001\n", 26 | "# Зададим количество эпох\n", 27 | "epochs = 3000\n", 28 | "\n", 29 | "# Создадим массив входных данных x\n", 30 | "arr_x = [1, 2, 3, 3.5, 4, 6, 7.5, 8.5, 9]\n", 31 | "# Создадим массив целевых значений (ответы Y)\n", 32 | "arr_y = [2.4, 4.5, 5.5, 6.4, 8.5, 11.7, 16.1, 16.5, 18.3]\n", 33 | "\n", 34 | "# Прогон по выборке\n", 35 | "for e in range(epochs):\n", 36 | " for i in range(len(arr_x)): # len(arr) - функция возвращает длину массива\n", 37 | " # Получить x координату точки\n", 38 | " x = arr_x[i]\n", 39 | " \n", 40 | " # Получить расчетную y, координату точки\n", 41 | " y = A * x \n", 42 | " \n", 43 | " # Получить целевую Y, координату точки\n", 44 | " target_Y = arr_y[i]\n", 45 | "\n", 46 | " # Ошибка E = целевое значение - выход нейрона\n", 47 | " E = target_Y - y\n", 48 | " \n", 49 | " # Меняем коэффициент при x, в соответствии с правилом A+дельтаA = A\n", 50 | " A += lr*(E/x)\n", 51 | "\n", 52 | "# Вывод данных готовой прямой\n", 53 | "print('Готовая прямая: y = ', A, '* X')" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 9, 59 | "metadata": {}, 60 | "outputs": [ 61 | { 62 | "data": { 63 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCCFsnCQCIYSwcZIIhBDCxv0/mMUxR7rl8SEAAAAASUVORK5CYII=\n", 64 | "text/plain": [ 65 | "" 66 | ] 67 | }, 68 | "metadata": {}, 69 | "output_type": "display_data" 70 | } 71 | ], 72 | "source": [ 73 | "import matplotlib.pyplot as plt\n", 74 | "%matplotlib inline\n", 75 | "\n", 76 | "# Функция для отображения входных данных\n", 77 | "def func_data(x_data):\n", 78 | " return [arr_y[i] for i in range(len(arr_y))]\n", 79 | "\n", 80 | "# Функция для отображения начальной прямой\n", 81 | "def func_begin(x_begin):\n", 82 | " return [A_vis*i for i in x_begin]\n", 83 | "\n", 84 | "# Функция для отображения готовой прямой\n", 85 | "def func(x):\n", 86 | " return [A*i for i in x]\n", 87 | "\n", 88 | "# Значения по X входных данных \n", 89 | "x_data = arr_x\n", 90 | "\n", 91 | "# Значения по X начальной прямой (диапазон значений) \n", 92 | "x_begin = [i for i in range(0, 11)]\n", 93 | "\n", 94 | "# Значения по X готовой прямой (диапазон значений) \n", 95 | "x = [i for i in range(0, 11)]\n", 96 | "#x = np.arange(0,11,1)\n", 97 | "\n", 98 | "# Значения по Y входных данных\n", 99 | "y_data = func_data(x_data)\n", 100 | "\n", 101 | "# Значения по Y начальной прямой\n", 102 | "y_begin = func_begin(x_begin)\n", 103 | "\n", 104 | "# Значения по Y готовой прямой\n", 105 | "y = func(x)\n", 106 | "\n", 107 | "# Зададим имена графику и числовым координатам\n", 108 | "plt.title(\"Neuron\")\n", 109 | "plt.xlabel(\"X\")\n", 110 | "plt.ylabel(\"Y\")\n", 111 | "\n", 112 | "# Зададим имена входным данным и прямым \n", 113 | "plt.plot(x,y, label='Входные данные', color = 'g') \n", 114 | "plt.plot(x,y, label='Готовая прямая', color = 'r')\n", 115 | "plt.plot(x,y, label='Начальная прямая', color = 'b') \n", 116 | "plt.legend(loc=2) #loc - локация имени, 2 - справа в углу\n", 117 | "\n", 118 | "# представляем точки данных (х,у) кружочками диаметра 10\n", 119 | "plt.scatter(x_data, y_data, color ='g', s=10) \n", 120 | "# Начальная прямая\n", 121 | "plt.plot(x_begin, y_begin, 'b')\n", 122 | "# Готовая прямая\n", 123 | "plt.plot(x, y, 'r') \n", 124 | "# Сетка на фоне для улучшения восприятия\n", 125 | "plt.grid(True, linestyle='-', color='0.75')\n", 126 | "# Показать график \n", 127 | "plt.show()" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": 11, 133 | "metadata": {}, 134 | "outputs": [ 135 | { 136 | "name": "stdout", 137 | "output_type": "stream", 138 | "text": [ 139 | "Введите значение ширины Х: 4\n", 140 | "Введите значение высоты Y: 15\n", 141 | "Это жираф!\n" 142 | ] 143 | } 144 | ], 145 | "source": [ 146 | "x = input(\"Введите значение ширины Х: \")\n", 147 | "x = int(x)\n", 148 | "T = input(\"Введите значение высоты Y: \")\n", 149 | "T = int(T)\n", 150 | "y = A * x \n", 151 | "\n", 152 | "# Условие\n", 153 | "if T > y:\n", 154 | " print('Это жираф!')\n", 155 | "else:\n", 156 | " print('Это крокодил!')" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": { 163 | "collapsed": true 164 | }, 165 | "outputs": [], 166 | "source": [] 167 | } 168 | ], 169 | "metadata": { 170 | "kernelspec": { 171 | "display_name": "Python 3", 172 | "language": "python", 173 | "name": "python3" 174 | }, 175 | "language_info": { 176 | "codemirror_mode": { 177 | "name": "ipython", 178 | "version": 3 179 | }, 180 | "file_extension": ".py", 181 | "mimetype": "text/x-python", 182 | "name": "python", 183 | "nbconvert_exporter": "python", 184 | "pygments_lexer": "ipython3", 185 | "version": "3.6.3" 186 | } 187 | }, 188 | "nbformat": 4, 189 | "nbformat_minor": 2 190 | } 191 | -------------------------------------------------------------------------------- /neuralmaster/4/Neuron_yes_b.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 22, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "Начальная прямая: 0.4 * X + 0.3652477754014445\n", 13 | "Готовая прямая: 2.058410130422831 * X + 2.5013583972057263\n" 14 | ] 15 | } 16 | ], 17 | "source": [ 18 | "import random\n", 19 | "\n", 20 | "# Инициализируем любым числом крутизны наклона прямой w1 = A\n", 21 | "w1 = 0.4\n", 22 | "w1_vis = w1 # Запоминаем начальное значение крутизны наклона\n", 23 | "# Инициализируем параметр w2 = b - отвечающий за точку прохождения прямой через ос Y\n", 24 | "w2 = random.uniform(-4, 4) \n", 25 | "w2_vis = w2 # Запоминаем начальное значение параметра\n", 26 | "# Вывод данных начальной прямой\n", 27 | "print('Начальная прямая: ', w1, '* X + ', w2)\n", 28 | "\n", 29 | "# Скорость обучения\n", 30 | "lr = 0.001\n", 31 | "# Зададим количество эпох\n", 32 | "epochs = 3000\n", 33 | "\n", 34 | "# Создадим массив (выборку входных данных) входных данных x1\n", 35 | "arr_x1 = [1, 2, 3, 3.5, 4, 6, 7.5, 8.5, 9]\n", 36 | "\n", 37 | "# Значение входных данных второго входа всегда равно 1\n", 38 | "x2 = 1\n", 39 | "\n", 40 | "# Создадим массив значений (целевых значений)\n", 41 | "arr_y = [4.3, 7, 8.0, 10.1, 11.3, 14.2, 18.5, 19.3, 21.4]\n", 42 | "\n", 43 | "# Прогон по выборке\n", 44 | "for e in range(epochs):\n", 45 | " for i in range(len(arr_x1)): # len(arr) - функция возвращает длину массива\n", 46 | " # Получить x координату точки\n", 47 | " x1 = arr_x1[i]\n", 48 | " \n", 49 | " # Получить расчетную y, координату точки\n", 50 | " y = w1 * x1 + w2 \n", 51 | " \n", 52 | " # Получить целевую Y, координату точки\n", 53 | " target_Y = arr_y[i]\n", 54 | "\n", 55 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 56 | " E = - (target_Y - y)\n", 57 | " \n", 58 | " # Меняем вес при x, в соответствии с правилом обновления веса\n", 59 | " w1 -= lr * E * x1\n", 60 | " \n", 61 | " # Меняем вес при x2 = 1 \n", 62 | " #w2 -= rate * E * x2 # Т.к. x2 = 1, то этот множитель можно не писать\n", 63 | " w2 -= lr * E \n", 64 | "\n", 65 | "# Вывод данных готовой прямой\n", 66 | "print('Готовая прямая: ', w1, '* X + ', w2)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 23, 72 | "metadata": {}, 73 | "outputs": [ 74 | { 75 | "data": { 76 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nA+RiSV8AAAAASUVORK5CYII=\n", 77 | "text/plain": [ 78 | "" 79 | ] 80 | }, 81 | "metadata": {}, 82 | "output_type": "display_data" 83 | } 84 | ], 85 | "source": [ 86 | "import matplotlib.pyplot as plt\n", 87 | "%matplotlib inline\n", 88 | "# Функция для отображения входных данных\n", 89 | "def func_data(x_data):\n", 90 | " return [arr_y[i] for i in range(len(arr_y))]\n", 91 | "\n", 92 | "# Функция для отображения начальной прямой\n", 93 | "def func_begin(x_begin):\n", 94 | " return [w1_vis*i + w2_vis for i in x_begin]\n", 95 | "\n", 96 | "# Функция для отображения готовой прямой\n", 97 | "def func(x):\n", 98 | " return [w1*i + w2 for i in x]\n", 99 | "\n", 100 | "# Значения по X входных данных \n", 101 | "x_data = arr_x1\n", 102 | "\n", 103 | "# Значения по X начальной прямой (диапазон значений) \n", 104 | "x_begin = [i for i in range(0, 11)]\n", 105 | "\n", 106 | "# Значения по X готовой прямой (диапазон значений) \n", 107 | "x = [i for i in range(0, 11)]\n", 108 | "#x = np.arange(0,11,1)\n", 109 | "\n", 110 | "# Значения по Y входных данных\n", 111 | "y_data = func_data(x_data)\n", 112 | "\n", 113 | "# Значения по Y начальной прямой\n", 114 | "y_begin = func_begin(x_begin)\n", 115 | "\n", 116 | "# Значения по Y готовой прямой\n", 117 | "y = func(x)\n", 118 | "\n", 119 | "# Зададим имена графику и числовым координатам\n", 120 | "plt.title(\"Neuron_evolution_№1\")\n", 121 | "plt.xlabel(\"X\")\n", 122 | "plt.ylabel(\"Y\")\n", 123 | "\n", 124 | "# Зададим имена входным данным и прямым \n", 125 | "plt.plot(x,y, label='Входные данные', color = 'g') \n", 126 | "plt.plot(x,y, label='Готовая прямая', color = 'r')\n", 127 | "plt.plot(x,y, label='Начальная прямая', color = 'b') \n", 128 | "plt.legend(loc=2) #loc - локация имени, 2 - справа в углу\n", 129 | "\n", 130 | "# представляем точки данных (х,у) кружочками диаметра 10\n", 131 | "plt.scatter(x_data, y_data, color ='g', s=10) \n", 132 | "# Начальная прямая\n", 133 | "plt.plot(x_begin, y_begin, 'b')\n", 134 | "# Готовая прямая\n", 135 | "plt.plot(x, y, 'r') \n", 136 | "# Сетка на фоне для улучшения восприятия\n", 137 | "plt.grid(True, linestyle='-', color='0.75')\n", 138 | "# Показать график \n", 139 | "plt.show()" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 3, 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | "Введите значение ширины Х: 4\n", 152 | "Введите значение высоты Y: 15\n", 153 | "Это жираф!\n" 154 | ] 155 | } 156 | ], 157 | "source": [ 158 | "x1 = input(\"Введите значение ширины Х: \")\n", 159 | "x1 = int(x1)\n", 160 | "T = input(\"Введите значение высоты Y: \")\n", 161 | "T = int(T)\n", 162 | "y = w1 * x1 + w2\n", 163 | "\n", 164 | "# Условие\n", 165 | "if T > y:\n", 166 | " print('Это жираф!')\n", 167 | "else:\n", 168 | " print('Это крокодил!')" 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": null, 174 | "metadata": { 175 | "collapsed": true 176 | }, 177 | "outputs": [], 178 | "source": [] 179 | } 180 | ], 181 | "metadata": { 182 | "kernelspec": { 183 | "display_name": "Python 3", 184 | "language": "python", 185 | "name": "python3" 186 | }, 187 | "language_info": { 188 | "codemirror_mode": { 189 | "name": "ipython", 190 | "version": 3 191 | }, 192 | "file_extension": ".py", 193 | "mimetype": "text/x-python", 194 | "name": "python", 195 | "nbconvert_exporter": "python", 196 | "pygments_lexer": "ipython3", 197 | "version": "3.6.3" 198 | } 199 | }, 200 | "nbformat": 4, 201 | "nbformat_minor": 2 202 | } 203 | -------------------------------------------------------------------------------- /neuralmaster/5/Neuron_log_and.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 4, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "Начальные весовые коэффициенты: \n", 13 | "w1 = 0.9491869921653935 \n", 14 | "w2 = 1.28402471824886 \n", 15 | "w3 = -0.08281146388163485\n", 16 | "\n", 17 | "Обученные весовые коэффициенты: \n", 18 | "w1 = 1.23318699217 \n", 19 | "w2 = 1.56802471825 \n", 20 | "w3 = 0.201188536118\n", 21 | "\n", 22 | "Проверка логической функции (И):\n", 23 | "( 0, 0, 0 )\n", 24 | "( 1, 0, 0 )\n", 25 | "( 0, 1, 0 )\n", 26 | "( 1, 1, 1 )\n" 27 | ] 28 | } 29 | ], 30 | "source": [ 31 | "import random\n", 32 | "import numpy as np\n", 33 | "\n", 34 | "# Инициализируем любым числом крутизны наклона прямой w1 = A\n", 35 | "w1 = random.uniform(-4, 4)\n", 36 | "w1_vis = w1 # Запоминаем начальное веса w1\n", 37 | "\n", 38 | "# Инициализируем параметр w2 = b - отвечающий за точку прохождения прямой через ось Y\n", 39 | "w2 = random.uniform(-4, 4) \n", 40 | "w2_vis = w2 # Запоминаем начальное значение веса w2\n", 41 | "\n", 42 | "# Инициализируем свободный параметр w3 = b \n", 43 | "w3 = random.uniform(-4, 4)\n", 44 | "w3_vis = w3 # Запоминаем начальное значение веса w3\n", 45 | "\n", 46 | "# Вывод данных начальных значений весовых коэффициентов\n", 47 | "print('Начальные весовые коэффициенты:', '\\nw1 = ', w1, '\\nw2 = ', w2, '\\nw3 = ', w3)\n", 48 | "\n", 49 | "# Скорость обучения\n", 50 | "lr = 0.001\n", 51 | "# Зададим количество эпох\n", 52 | "epochs = 5000\n", 53 | "# Зададим порог единичной функции активации\n", 54 | "bias = 3\n", 55 | "\n", 56 | "# Создадим массив данных функции логического (И)\n", 57 | "log_and = np.array([[0, 0, 0],\n", 58 | " [1, 0, 0],\n", 59 | " [0, 1, 0],\n", 60 | " [1, 1, 1]])\n", 61 | "\n", 62 | "# Прогон по выборке\n", 63 | "for e in range(epochs):\n", 64 | " for i in range(log_and.shape[0]): # shape - возвращает размерность массива, [0] - индекс числа строк в массиве\n", 65 | " # Получить x1 координату точки\n", 66 | " x1 = log_and[i, 0] # i - строка, 0 -столбец\n", 67 | " \n", 68 | " # Получить x2 координату точки\n", 69 | " x2 = log_and[i, 1] # i - строка, 1 -столбец\n", 70 | " \n", 71 | " # Взвешенная сумма\n", 72 | " y = (w1 * x1) + (w2 * x2) + w3\n", 73 | " \n", 74 | " if y >= bias:\n", 75 | " # Когда превышено пороговое значение, выход должен быть - y = 1\n", 76 | " y = 1\n", 77 | " # Получить целевую Y, координату точки\n", 78 | " target_Y = log_and[i, 2] # i - строка, 2 -столбец \n", 79 | "\n", 80 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 81 | " E = - (target_Y - y)\n", 82 | " \n", 83 | " # Меняем вес при x1\n", 84 | " w1 -= lr * E * x1\n", 85 | " \n", 86 | " # Меняем вес при x2\n", 87 | " w2 -= lr * E * x2\n", 88 | " \n", 89 | " # Меняем вес при x3 = 1 \n", 90 | " w3 -= lr * E\n", 91 | " else:\n", 92 | " # Когда не превышено пороговое значение, выход должен быть - y = 0\n", 93 | " y = 0\n", 94 | " # Получить целевую Y, координату точки\n", 95 | " target_Y = log_and[i, 2] # i - строка, 2 -столбец\n", 96 | "\n", 97 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 98 | " E = - (target_Y - y)\n", 99 | " \n", 100 | " # Меняем вес при x1\n", 101 | " w1 -= lr * E * x1\n", 102 | " \n", 103 | " # Меняем вес при x2\n", 104 | " w2 -= lr * E * x2\n", 105 | " \n", 106 | " # Меняем вес при x3 = 1 \n", 107 | " w3 -= lr * E\n", 108 | "\n", 109 | "# Вывод данных готовой прямой\n", 110 | "print('\\nОбученные весовые коэффициенты:', '\\nw1 = ', w1, '\\nw2 = ', w2, '\\nw3 = ', w3)\n", 111 | "\n", 112 | "print('\\nПроверка логической функции (И):')\n", 113 | "print('( 0, 0,', int((0*w1 + 0*w2 + w3)>=3), ')')\n", 114 | "print('( 1, 0,', int((1*w1 + 0*w2+ w3)>=3), ')')\n", 115 | "print('( 0, 1,', int((0*w1 + 1*w2+ w3)>=3), ')')\n", 116 | "print('( 1, 1,', int((1*w1 + 1*w2+ w3)>=3), ')')" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "metadata": { 123 | "collapsed": true 124 | }, 125 | "outputs": [], 126 | "source": [] 127 | } 128 | ], 129 | "metadata": { 130 | "kernelspec": { 131 | "display_name": "Python 3", 132 | "language": "python", 133 | "name": "python3" 134 | }, 135 | "language_info": { 136 | "codemirror_mode": { 137 | "name": "ipython", 138 | "version": 3 139 | }, 140 | "file_extension": ".py", 141 | "mimetype": "text/x-python", 142 | "name": "python", 143 | "nbconvert_exporter": "python", 144 | "pygments_lexer": "ipython3", 145 | "version": "3.6.3" 146 | } 147 | }, 148 | "nbformat": 4, 149 | "nbformat_minor": 2 150 | } 151 | -------------------------------------------------------------------------------- /neuralmaster/5/Neuron_log_and_sigma.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 15, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "Начальные весовые коэффициенты: \n", 13 | "w1 = -0.10327178141308457 \n", 14 | "w2 = -0.24117855863067605\n", 15 | "\n", 16 | "Обученные весовые коэффициенты: \n", 17 | "w1 = -0.103271781413 \n", 18 | "w2 = -0.241178558631\n", 19 | "\n", 20 | "Проверка логической функции (И):\n", 21 | "( 0, 0, 0.5 )\n", 22 | "( 1, 0, 0.474204976031 )\n", 23 | "( 0, 1, 0.439995933957 )\n", 24 | "( 1, 1, 0.414728842932 )\n" 25 | ] 26 | } 27 | ], 28 | "source": [ 29 | "import random\n", 30 | "import numpy as np\n", 31 | "\n", 32 | "# Инициализируем любым числом крутизны наклона прямой w1 = A\n", 33 | "w1 = random.uniform(-0.5, 0.5)\n", 34 | "w1_vis = w1 # Запоминаем начальное веса w1\n", 35 | "\n", 36 | "# Инициализируем параметр w2 = b - отвечающий за точку прохождения прямой через ос Y\n", 37 | "w2 = random.uniform(-0.5, 0.5) \n", 38 | "w2_vis = w2 # Запоминаем начальное значение веса w2\n", 39 | "\n", 40 | "# Вывод данных начальных значений весовых коэффициентов\n", 41 | "print('Начальные весовые коэффициенты:', '\\nw1 = ', w1, '\\nw2 = ', w2)\n", 42 | "\n", 43 | "# Скорость обучения\n", 44 | "lr = 0.01\n", 45 | "# Зададим количество эпох\n", 46 | "epochs = 10000\n", 47 | "\n", 48 | "# Создадим массив данных функции логического (И)\n", 49 | "log_and = np.array([[0, 0, 0],\n", 50 | " [1, 0, 0],\n", 51 | " [0, 0, 0],\n", 52 | " [1, 1, 1]])\n", 53 | "\n", 54 | "# Прогон по выборке\n", 55 | "for e in range(epochs):\n", 56 | " for i in range(log_and.shape[0]): # shape - возвращает размерность массива, [0] - индекс числа строк в массиве\n", 57 | " # Получить x1 координату точки\n", 58 | " x1 = log_and[i, 0] # i - строка, 0 -столбец\n", 59 | " \n", 60 | " # Получить x2 координату точки\n", 61 | " x2 = log_and[i, 1] # i - строка, 1 -столбец\n", 62 | " \n", 63 | " # Взвешенная сумма\n", 64 | " x = (w1 * x1) + (w2 * x2)\n", 65 | " # Функция активации\n", 66 | " y = 1/(1+np.exp(-x))\n", 67 | " \n", 68 | " # Получить целевую Y, координату точки\n", 69 | " target_Y = log_and[i, 2] # i - строка, 2 -столбец \n", 70 | " \n", 71 | " # Если выход больше 0,5, то считаем что ответ верный\n", 72 | " if y >= 0.5:\n", 73 | " y = 1\n", 74 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 75 | " E = - (target_Y - y)\n", 76 | " \n", 77 | " # Меняем вес при x1\n", 78 | " w1 -= lr * E * y * (1.0 - y) * x1\n", 79 | " \n", 80 | " # Меняем вес при x2\n", 81 | " w2 -= lr * E * y * (1.0 - y) * x2\n", 82 | " else:\n", 83 | " y = 0\n", 84 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 85 | " E = - (target_Y - y)\n", 86 | " \n", 87 | " # Меняем вес при x1\n", 88 | " w1 -= lr * E * y * (1.0 - y) * x1\n", 89 | " \n", 90 | " # Меняем вес при x2\n", 91 | " w2 -= lr * E * y * (1.0 - y) * x2\n", 92 | " \n", 93 | " \n", 94 | "# Вывод данных готовой прямой\n", 95 | "print('\\nОбученные весовые коэффициенты:', '\\nw1 = ', w1, '\\nw2 = ', w2)\n", 96 | "\n", 97 | "print('\\nПроверка логической функции (И):')\n", 98 | "x = (w1 * 0) + (w2 * 0)\n", 99 | "y = 1/(1+np.exp(-x))\n", 100 | "print('( 0, 0,', y, ')')\n", 101 | "x = (w1 * 1) + (w2 * 0)\n", 102 | "y = 1/(1+np.exp(-x))\n", 103 | "print('( 1, 0,', y, ')')\n", 104 | "x = (w1 * 0) + (w2 * 1)\n", 105 | "y = 1/(1+np.exp(-x))\n", 106 | "print('( 0, 1,', y, ')')\n", 107 | "x = (w1 * 1) + (w2 * 1)\n", 108 | "y = 1/(1+np.exp(-x))\n", 109 | "print('( 1, 1,', y, ')')" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": { 116 | "collapsed": true 117 | }, 118 | "outputs": [], 119 | "source": [] 120 | } 121 | ], 122 | "metadata": { 123 | "kernelspec": { 124 | "display_name": "Python 3", 125 | "language": "python", 126 | "name": "python3" 127 | }, 128 | "language_info": { 129 | "codemirror_mode": { 130 | "name": "ipython", 131 | "version": 3 132 | }, 133 | "file_extension": ".py", 134 | "mimetype": "text/x-python", 135 | "name": "python", 136 | "nbconvert_exporter": "python", 137 | "pygments_lexer": "ipython3", 138 | "version": "3.6.3" 139 | } 140 | }, 141 | "nbformat": 4, 142 | "nbformat_minor": 2 143 | } 144 | -------------------------------------------------------------------------------- /neuralmaster/5/Neuron_log_or.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "Начальные весовые коэффициенты: \n", 13 | "w1 = 3.611365134992452 \n", 14 | "w2 = 3.8646266194092878\n", 15 | "\n", 16 | "Обученные весовые коэффициенты: \n", 17 | "w1 = 3.61136513499 \n", 18 | "w2 = 3.86462661941\n", 19 | "\n", 20 | "Проверка логической функции (И):\n", 21 | "( 0, 0, 0 )\n", 22 | "( 1, 0, 1 )\n", 23 | "( 0, 1, 1 )\n", 24 | "( 1, 1, 1 )\n" 25 | ] 26 | } 27 | ], 28 | "source": [ 29 | "import random\n", 30 | "import numpy as np\n", 31 | "\n", 32 | "# Инициализируем любым числом крутизны наклона прямой w1 = A\n", 33 | "w1 = random.uniform(-4, 4)\n", 34 | "w1_vis = w1 # Запоминаем начальное веса w1\n", 35 | "\n", 36 | "# Инициализируем параметр w2 = b - отвечающий за точку прохождения прямой через ос Y\n", 37 | "w2 = random.uniform(-4, 4) \n", 38 | "w2_vis = w2 # Запоминаем начальное значение веса w2\n", 39 | "\n", 40 | "# Вывод данных начальных значений весовых коэффициентов\n", 41 | "print('Начальные весовые коэффициенты:', '\\nw1 = ', w1, '\\nw2 = ', w2)\n", 42 | "\n", 43 | "# Скорость обучения\n", 44 | "lr = 0.001\n", 45 | "# Зададим количество эпох\n", 46 | "epochs = 5000\n", 47 | "# Зададим порог единичной функции активации\n", 48 | "bias = 3\n", 49 | "\n", 50 | "# Создадим массив данных функции логического (И)\n", 51 | "log_or = np.array([[0, 0, 0],\n", 52 | " [1, 0, 1],\n", 53 | " [0, 1, 1],\n", 54 | " [1, 1, 1]])\n", 55 | "\n", 56 | "# Прогон по выборке\n", 57 | "for e in range(epochs):\n", 58 | " for i in range(log_or.shape[0]): # shape - возвращает размерность массива, [0] - индекс числа строк в массиве\n", 59 | " # Получить x1 координату точки\n", 60 | " x1 = log_or[i, 0] # i - строка, 0 -столбец\n", 61 | " \n", 62 | " # Получить x2 координату точки\n", 63 | " x2 = log_or[i, 1] # i - строка, 1 -столбец\n", 64 | " \n", 65 | " # Взвешенная сумма\n", 66 | " y = (w1 * x1) + (w2 * x2)\n", 67 | " \n", 68 | " if y >= bias:\n", 69 | " # Когда превышено пороговое значение, выход должен быть - y = 1\n", 70 | " y = 1\n", 71 | " # Получить целевую Y, координату точки\n", 72 | " target_Y = log_or[i, 2] # i - строка, 2 -столбец \n", 73 | "\n", 74 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 75 | " E = - (target_Y - y)\n", 76 | " \n", 77 | " # Меняем вес при x1\n", 78 | " w1 -= lr * E * x1\n", 79 | " \n", 80 | " # Меняем вес при x2\n", 81 | " w2 -= lr * E * x2\n", 82 | " \n", 83 | " else:\n", 84 | " # Когда не превышено пороговое значение, выход должен быть - y = 0\n", 85 | " y = 0\n", 86 | " # Получить целевую Y, координату точки\n", 87 | " target_Y = log_or[i, 2] # i - строка, 2 -столбец\n", 88 | "\n", 89 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 90 | " E = - (target_Y - y)\n", 91 | " \n", 92 | " # Меняем вес при x1\n", 93 | " w1 -= lr * E * x1\n", 94 | " \n", 95 | " # Меняем вес при x2\n", 96 | " w2 -= lr * E * x2\n", 97 | " \n", 98 | "\n", 99 | "# Вывод данных готовой прямой\n", 100 | "print('\\nОбученные весовые коэффициенты:', '\\nw1 = ', w1, '\\nw2 = ', w2)\n", 101 | "\n", 102 | "print('\\nПроверка логической функции (И):')\n", 103 | "print('( 0, 0,', int((0*w1 + 0*w2)>=3), ')')\n", 104 | "print('( 1, 0,', int((1*w1 + 0*w2)>=3), ')')\n", 105 | "print('( 0, 1,', int((0*w1 + 1*w2)>=3), ')')\n", 106 | "print('( 1, 1,', int((1*w1 + 1*w2)>=3), ')')" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": { 113 | "collapsed": true 114 | }, 115 | "outputs": [], 116 | "source": [] 117 | } 118 | ], 119 | "metadata": { 120 | "kernelspec": { 121 | "display_name": "Python 3", 122 | "language": "python", 123 | "name": "python3" 124 | }, 125 | "language_info": { 126 | "codemirror_mode": { 127 | "name": "ipython", 128 | "version": 3 129 | }, 130 | "file_extension": ".py", 131 | "mimetype": "text/x-python", 132 | "name": "python", 133 | "nbconvert_exporter": "python", 134 | "pygments_lexer": "ipython3", 135 | "version": "3.6.3" 136 | } 137 | }, 138 | "nbformat": 4, 139 | "nbformat_minor": 2 140 | } 141 | -------------------------------------------------------------------------------- /neuralmaster/5/Neuron_no_or.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 9, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "Начальные весовые коэффициенты: \n", 13 | "w1 = -3.3354528236406162 \n", 14 | "w2 = -3.673516003183982 \n", 15 | "w3 = -0.8006955724395874\n", 16 | "\n", 17 | "Обученные весовые коэффициенты: \n", 18 | "w1 = -0.00245282364087 \n", 19 | "w2 = -0.00251600318428 \n", 20 | "w3 = 3.00230442756\n", 21 | "\n", 22 | "Проверка логической функции (И):\n", 23 | "( 0, 0, 1 )\n", 24 | "( 1, 0, 0 )\n", 25 | "( 0, 1, 0 )\n", 26 | "( 1, 1, 0 )\n" 27 | ] 28 | } 29 | ], 30 | "source": [ 31 | "import random\n", 32 | "import numpy as np\n", 33 | "\n", 34 | "# Инициализируем любым числом крутизны наклона прямой w1 = A\n", 35 | "w1 = random.uniform(-4, 4)\n", 36 | "w1_vis = w1 # Запоминаем начальное веса w1\n", 37 | "\n", 38 | "# Инициализируем параметр w2 = b - отвечающий за точку прохождения прямой через ос Y\n", 39 | "w2 = random.uniform(-4, 4) \n", 40 | "w2_vis = w2 # Запоминаем начальное значение веса w2\n", 41 | "\n", 42 | "# Инициализируем свободный параметр w3 = b \n", 43 | "w3 = random.uniform(-4, 4)\n", 44 | "w3_vis = w3 # Запоминаем начальное значение веса w3\n", 45 | "\n", 46 | "# Вывод данных начальных значений весовых коэффициентов\n", 47 | "print('Начальные весовые коэффициенты:', '\\nw1 = ', w1, '\\nw2 = ', w2, '\\nw3 = ', w3)\n", 48 | "\n", 49 | "# Скорость обучения\n", 50 | "lr = 0.001\n", 51 | "# Зададим количество эпох\n", 52 | "epochs = 10000\n", 53 | "# Зададим порог единичной функции активации\n", 54 | "bias = 3\n", 55 | "\n", 56 | "# Создадим массив данных функции логического (И)\n", 57 | "log_and = np.array([[0, 0, 0],\n", 58 | " [1, 0, 1],\n", 59 | " [0, 1, 1],\n", 60 | " [1, 1, 0]])\n", 61 | "\n", 62 | "# Прогон по выборке\n", 63 | "for e in range(epochs):\n", 64 | " for i in range(log_and.shape[0]): # shape - возвращает размерность массива, [0] - индекс числа строк в массиве\n", 65 | " # Получить x1 координату точки\n", 66 | " x1 = log_and[i, 0] # i - строка, 0 -столбец\n", 67 | " \n", 68 | " # Получить x2 координату точки\n", 69 | " x2 = log_and[i, 1] # i - строка, 1 -столбец\n", 70 | " \n", 71 | " # Взвешенная сумма\n", 72 | " y = (w1 * x1) + (w2 * x2) + w3\n", 73 | " \n", 74 | " if y >= bias:\n", 75 | " # Когда превышено пороговое значение, выход должен быть - y = 1\n", 76 | " y = 1\n", 77 | " # Получить целевую Y, координату точки\n", 78 | " target_Y = log_and[i, 2] # i - строка, 2 -столбец \n", 79 | "\n", 80 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 81 | " E = - (target_Y - y)\n", 82 | " \n", 83 | " # Меняем вес при x1\n", 84 | " w1 -= lr * E * x1\n", 85 | " \n", 86 | " # Меняем вес при x2\n", 87 | " w2 -= lr * E * x2\n", 88 | " \n", 89 | " # Меняем вес при x3 = 1 \n", 90 | " w3 -= lr * E\n", 91 | " else:\n", 92 | " # Когда не превышено пороговое значение, выход должен быть - y = 0\n", 93 | " y = 0\n", 94 | " # Получить целевую Y, координату точки\n", 95 | " target_Y = log_and[i, 2] # i - строка, 2 -столбец\n", 96 | "\n", 97 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 98 | " E = - (target_Y - y)\n", 99 | " \n", 100 | " # Меняем вес при x1\n", 101 | " w1 -= lr * E * x1\n", 102 | " \n", 103 | " # Меняем вес при x2\n", 104 | " w2 -= lr * E * x2\n", 105 | " \n", 106 | " # Меняем вес при x3 = 1 \n", 107 | " w3 -= lr * E\n", 108 | " \n", 109 | "\n", 110 | "# Вывод данных готовой прямой\n", 111 | "print('\\nОбученные весовые коэффициенты:', '\\nw1 = ', w1, '\\nw2 = ', w2, '\\nw3 = ', w3)\n", 112 | "\n", 113 | "print('\\nПроверка логической функции (И):')\n", 114 | "print('( 0, 0,', int((0*w1 + 0*w2 + w3)>=3), ')')\n", 115 | "print('( 1, 0,', int((1*w1 + 0*w2+ w3)>=3), ')')\n", 116 | "print('( 0, 1,', int((0*w1 + 1*w2+ w3)>=3), ')')\n", 117 | "print('( 1, 1,', int((1*w1 + 1*w2+ w3)>=3), ')')" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": null, 123 | "metadata": { 124 | "collapsed": true 125 | }, 126 | "outputs": [], 127 | "source": [] 128 | } 129 | ], 130 | "metadata": { 131 | "kernelspec": { 132 | "display_name": "Python 3", 133 | "language": "python", 134 | "name": "python3" 135 | }, 136 | "language_info": { 137 | "codemirror_mode": { 138 | "name": "ipython", 139 | "version": 3 140 | }, 141 | "file_extension": ".py", 142 | "mimetype": "text/x-python", 143 | "name": "python", 144 | "nbconvert_exporter": "python", 145 | "pygments_lexer": "ipython3", 146 | "version": "3.6.3" 147 | } 148 | }, 149 | "nbformat": 4, 150 | "nbformat_minor": 2 151 | } 152 | -------------------------------------------------------------------------------- /neuralmaster/5/number_bin/Neuron_number_bin0.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import numpy as np" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 2, 17 | "metadata": {}, 18 | "outputs": [], 19 | "source": [ 20 | "# Загрузить и подготовить тренировочные данные из формата CSV в список\n", 21 | "training_data = open(\"dataset/Data_train.csv\", 'r') # 'r' - открываем файл для чтения\n", 22 | "training_data_list = training_data.readlines() # readlines() - читает все строки в файле в переменную training_data_list\n", 23 | "training_data.close() # закрываем файл csv\n", 24 | "\n", 25 | "# Загрузить и подготовить тестовые данные из формата CSV в список\n", 26 | "test_data = open(\"dataset/Data_test.csv\", 'r') # 'r' - открываем файл для чтения\n", 27 | "test_data_list = test_data.readlines()# Загрузить и подготовить тестовые данные из формата CSV в список \n", 28 | "test_data.close() # закрываем файл csv" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 3, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "# Инициализация весов нейрона\n", 38 | "weights = np.zeros(15)\n", 39 | "\n", 40 | "# Скорость обучения\n", 41 | "lr = 1\n", 42 | "\n", 43 | "# Зададим количество эпох\n", 44 | "epochs = 1000\n", 45 | "\n", 46 | "# Зададим порог единичной функции активации\n", 47 | "bias = 3" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 4, 53 | "metadata": {}, 54 | "outputs": [], 55 | "source": [ 56 | "# Прогон по обучающей выборке\n", 57 | "for e in range(epochs):\n", 58 | " for i in training_data_list:\n", 59 | " # Получить входные данные числа\n", 60 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 61 | " inputs_x = np.asfarray(all_values[1:])\n", 62 | " \n", 63 | " # Получить целевое значение Y, (ответ - какое это число)\n", 64 | " target_Y = int(all_values[0]) # перевод символов в int, 0 элемент - ответ\n", 65 | "\n", 66 | " # Переводим целевой результат в бинарный вид. Так как мы ищем только значение ноль, значит только он будет верным = 1.\n", 67 | " # остальные ответы, будут неверными, соответственно они обращаются в ноль.\n", 68 | " if target_Y == 0:\n", 69 | " target_Y = 1\n", 70 | " else:\n", 71 | " target_Y = 0\n", 72 | " \n", 73 | " \n", 74 | " # Взвешенная сумма\n", 75 | " y = np.sum(weights * inputs_x)\n", 76 | " \n", 77 | " if y >= bias:\n", 78 | " # Когда равно или превышено пороговое значение, выход должен быть - y = 1\n", 79 | " y = 1\n", 80 | " \n", 81 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 82 | " E = - (target_Y - y)\n", 83 | " \n", 84 | " # Меняем веса по каждому из входов (дельта правило)\n", 85 | " weights -= lr * E * inputs_x\n", 86 | " \n", 87 | " else:\n", 88 | " # Когда не превышено пороговое значение, выход должен быть - y = 0\n", 89 | " y = 0\n", 90 | "\n", 91 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 92 | " E = - (target_Y - y)\n", 93 | " \n", 94 | " # Меняем веса по каждому из входов (дельта правило)\n", 95 | " weights -= lr * E * inputs_x" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 5, 101 | "metadata": {}, 102 | "outputs": [ 103 | { 104 | "name": "stdout", 105 | "output_type": "stream", 106 | "text": [ 107 | "Весовые коэффициенты:\n", 108 | " [ 0. 0. -2. 3. 0. 2. 0. -7. -2. 3. 0. 1. 0. 0. -2.]\n" 109 | ] 110 | } 111 | ], 112 | "source": [ 113 | "# Вывод обученых весов\n", 114 | "print('Весовые коэффициенты:\\n',weights)" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": 6, 120 | "metadata": {}, 121 | "outputs": [ 122 | { 123 | "name": "stdout", 124 | "output_type": "stream", 125 | "text": [ 126 | "0 это 0? True\n", 127 | "1 это 0? False\n", 128 | "2 это 0? False\n", 129 | "3 это 0? False\n", 130 | "4 это 0? False\n", 131 | "5 это 0? False\n", 132 | "6 это 0? False\n", 133 | "7 это 0? False\n", 134 | "8 это 0? False\n", 135 | "9 это 0? False\n" 136 | ] 137 | } 138 | ], 139 | "source": [ 140 | "# Еще раз пройдем по обучающей выборке\n", 141 | "for i in training_data_list:\n", 142 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 143 | " inputs_x = np.asfarray(all_values[1:])\n", 144 | " print(i[0], ' это 0? ', np.sum(weights * inputs_x)>=bias)" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": 7, 150 | "metadata": {}, 151 | "outputs": [ 152 | { 153 | "name": "stdout", 154 | "output_type": "stream", 155 | "text": [ 156 | "Узнал 0 - 1 ? True\n", 157 | "Узнал 0 - 2 ? True\n", 158 | "Узнал 0 - 3 ? True\n", 159 | "Узнал 0 - 4 ? True\n", 160 | "Узнал 0 - 5 ? True\n", 161 | "Узнал 0 - 6 ? True\n" 162 | ] 163 | } 164 | ], 165 | "source": [ 166 | "# Проход по тестовой выборке\n", 167 | "t = 0 # Счетчик номера нуля тестовой выборки\n", 168 | "for i in test_data_list:\n", 169 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 170 | " inputs_x = np.asfarray(all_values[1:])\n", 171 | " t += 1\n", 172 | " print('Узнал 0 - ',t, '?', np.sum(weights * inputs_x)>=bias)" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "metadata": { 179 | "collapsed": true 180 | }, 181 | "outputs": [], 182 | "source": [] 183 | } 184 | ], 185 | "metadata": { 186 | "kernelspec": { 187 | "display_name": "Python 3", 188 | "language": "python", 189 | "name": "python3" 190 | }, 191 | "language_info": { 192 | "codemirror_mode": { 193 | "name": "ipython", 194 | "version": 3 195 | }, 196 | "file_extension": ".py", 197 | "mimetype": "text/x-python", 198 | "name": "python", 199 | "nbconvert_exporter": "python", 200 | "pygments_lexer": "ipython3", 201 | "version": "3.6.3" 202 | } 203 | }, 204 | "nbformat": 4, 205 | "nbformat_minor": 2 206 | } 207 | -------------------------------------------------------------------------------- /neuralmaster/5/number_bin/dataset/Data_test.csv: -------------------------------------------------------------------------------- 1 | 0,1,1,1,1,0,1,1,0,1,1,0,1,1,1,0 2 | 0,1,1,1,1,0,1,1,0,1,1,0,1,1,0,1 3 | 0,1,1,1,1,0,1,1,0,1,1,0,1,0,1,1 4 | 0,0,1,1,1,0,1,1,0,1,1,0,1,1,1,1 5 | 0,1,1,1,1,0,1,1,0,0,1,0,1,1,1,1 6 | 0,1,1,1,1,0,1,0,0,1,1,0,1,1,1,1 7 | -------------------------------------------------------------------------------- /neuralmaster/5/number_bin/dataset/Data_train.csv: -------------------------------------------------------------------------------- 1 | 0,1,1,1,1,0,1,1,0,1,1,0,1,1,1,1 2 | 1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1 3 | 2,1,1,1,0,0,1,1,1,1,1,0,0,1,1,1 4 | 3,1,1,1,0,0,1,1,1,1,0,0,1,1,1,1 5 | 4,1,0,1,1,0,1,1,1,1,0,0,1,0,0,1 6 | 5,1,1,1,1,0,0,1,1,1,0,0,1,1,1,1 7 | 6,1,1,1,1,0,0,1,1,1,1,0,1,1,1,1 8 | 7,1,1,1,0,0,1,0,0,1,0,0,1,0,0,1 9 | 8,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1 10 | 9,1,1,1,1,0,1,1,1,1,0,0,1,1,1,1 11 | -------------------------------------------------------------------------------- /neuralmaster/5/number_sigma/Neuron_number_sigma.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import numpy as np" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 2, 17 | "metadata": { 18 | "collapsed": true 19 | }, 20 | "outputs": [], 21 | "source": [ 22 | "# Загрузить и подготовить тренировочные данные из формата CSV в список\n", 23 | "training_data = open(\"dataset/Data_train.csv\", 'r') # 'r' - открываем файл для чтения\n", 24 | "training_data_list = training_data.readlines() # readlines() - читает все строки в файле в переменную training_data_list\n", 25 | "training_data.close() # закрываем файл csv\n", 26 | "\n", 27 | "# Загрузить и подготовить тестовые данные из формата CSV в список\n", 28 | "test_data = open(\"dataset/Data_test.csv\", 'r') # 'r' - открываем файл для чтения\n", 29 | "test_data_list = test_data.readlines()# Загрузить и подготовить тестовые данные из формата CSV в список \n", 30 | "test_data.close() # закрываем файл csv" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 3, 36 | "metadata": { 37 | "collapsed": true 38 | }, 39 | "outputs": [], 40 | "source": [ 41 | "# Инициализация весов нейрона\n", 42 | "weights = np.zeros(15)\n", 43 | "\n", 44 | "# Скорость обучения\n", 45 | "lr = 0.1\n", 46 | "\n", 47 | "# Зададим количество эпох\n", 48 | "epochs = 50000" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 4, 54 | "metadata": { 55 | "collapsed": true 56 | }, 57 | "outputs": [], 58 | "source": [ 59 | "# Прогон по обучающей выборке\n", 60 | "for e in range(epochs):\n", 61 | " for i in training_data_list:\n", 62 | " # Получить входные данные числа\n", 63 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 64 | " inputs_x = np.asfarray(all_values[1:])\n", 65 | " \n", 66 | " # Получить целевое значение Y, (ответ - какое это число)\n", 67 | " target_Y = int(all_values[0]) # перевод символов в int, 0 элемент - ответ\n", 68 | "\n", 69 | " # Так как мы ищем только значение ноль, значит только он будет верным ответом = 1.\n", 70 | " # остальные ответы, будут неверными, соответственно они обращаются в ноль.\n", 71 | " if target_Y == 0:\n", 72 | " target_Y = 1\n", 73 | " else:\n", 74 | " target_Y = 0\n", 75 | " \n", 76 | " # Взвешенная сумма\n", 77 | " x = np.sum(weights * inputs_x)\n", 78 | " # Функция активации\n", 79 | " y = 1/(1+np.exp(-x))\n", 80 | " \n", 81 | " # Ошибка E = -(целевое значение - выход нейрона)\n", 82 | " E = -(target_Y - y)\n", 83 | " \n", 84 | " # Меняем веса по каждому из входов \n", 85 | " weights -= lr * E * y * (1.0 - y) * inputs_x " 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 5, 91 | "metadata": {}, 92 | "outputs": [ 93 | { 94 | "name": "stdout", 95 | "output_type": "stream", 96 | "text": [ 97 | "Весовые коэффициенты:\n", 98 | " [ 0.44879589 -0.18430999 -0.02023563 2.0697523 -0.07193334 0.17307025\n", 99 | " -2.1606589 -5.35195696 -1.45815401 3.73096992 -1.31490847 0.26365056\n", 100 | " 0.52117981 0.94419683 -4.20017402]\n" 101 | ] 102 | } 103 | ], 104 | "source": [ 105 | "# Вывод обученных весов\n", 106 | "print('Весовые коэффициенты:\\n',weights)" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 6, 112 | "metadata": {}, 113 | "outputs": [ 114 | { 115 | "name": "stdout", 116 | "output_type": "stream", 117 | "text": [ 118 | "0 Вероятность что 0: 0.987440019679\n", 119 | "1 Вероятность что 0: 0.00493344023472\n", 120 | "2 Вероятность что 0: 0.00579884946173\n", 121 | "3 Вероятность что 0: 1.14519734014e-05\n", 122 | "4 Вероятность что 0: 3.43432571255e-05\n", 123 | "5 Вероятность что 0: 4.53774043971e-05\n", 124 | "6 Вероятность что 0: 0.00591089049169\n", 125 | "7 Вероятность что 0: 0.00365001935213\n", 126 | "8 Вероятность что 0: 0.00130998489482\n", 127 | "9 Вероятность что 0: 0.00885106765671\n" 128 | ] 129 | } 130 | ], 131 | "source": [ 132 | "# Еще раз пройдем по обучающей выборке\n", 133 | "for i in training_data_list:\n", 134 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 135 | " inputs_x = np.asfarray(all_values[1:])\n", 136 | " x = np.sum(weights * inputs_x)\n", 137 | " print(i[0], 'Вероятность что 0: ', 1/(1+np.exp(-x)))" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": 7, 143 | "metadata": {}, 144 | "outputs": [ 145 | { 146 | "name": "stdout", 147 | "output_type": "stream", 148 | "text": [ 149 | "Вероятность что узнал 0 - 1 ? 0.964467249281\n", 150 | "Вероятность что узнал 0 - 2 ? 0.98802530455\n", 151 | "Вероятность что узнал 0 - 3 ? 0.614232538622\n", 152 | "Вероятность что узнал 0 - 4 ? 0.905331401561\n", 153 | "Вероятность что узнал 0 - 5 ? 0.81811184231\n", 154 | "Вероятность что узнал 0 - 6 ? 0.74017734823\n" 155 | ] 156 | } 157 | ], 158 | "source": [ 159 | "# Проход по тестовой выборке\n", 160 | "t = 0 # Счетчик номера нуля тестовой выборки\n", 161 | "for i in test_data_list:\n", 162 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 163 | " inputs_x = np.asfarray(all_values[1:])\n", 164 | " t += 1\n", 165 | " x = np.sum(weights * inputs_x)\n", 166 | " \n", 167 | " print('Вероятность что узнал 0 -',t, '?', 1/(1+np.exp(-x)))" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": { 174 | "collapsed": true 175 | }, 176 | "outputs": [], 177 | "source": [] 178 | } 179 | ], 180 | "metadata": { 181 | "kernelspec": { 182 | "display_name": "Python 3", 183 | "language": "python", 184 | "name": "python3" 185 | }, 186 | "language_info": { 187 | "codemirror_mode": { 188 | "name": "ipython", 189 | "version": 3 190 | }, 191 | "file_extension": ".py", 192 | "mimetype": "text/x-python", 193 | "name": "python", 194 | "nbconvert_exporter": "python", 195 | "pygments_lexer": "ipython3", 196 | "version": "3.6.3" 197 | } 198 | }, 199 | "nbformat": 4, 200 | "nbformat_minor": 2 201 | } 202 | -------------------------------------------------------------------------------- /neuralmaster/5/number_sigma/dataset/Data_test.csv: -------------------------------------------------------------------------------- 1 | 0,1,0.5,1,1,0,1,1,0,1,0.7,0,1,1,1,0 2 | 0,1,1,1,0.9,0,1,1,0,0.8,1,0,1,1,1,0 3 | 0,1,1,1,0.4,0,1,1,0,1,1,0,1,0,1,0.5 4 | 0,0,1,0.2,1,0,1,1,0,1,1,0,1,1,0.6,0.3 5 | 0,1,0.6,1,1,0,1,1,0,0,1,0,1,0.7,1,1 6 | 0,1,1,1,0.4,0,1,0,0,1,1,0,1,1,1,1 7 | -------------------------------------------------------------------------------- /neuralmaster/5/number_sigma/dataset/Data_train.csv: -------------------------------------------------------------------------------- 1 | 0,1,1,1,1,0,1,0.4,0,1,1,0,1,1,1,0.3 2 | 1,0,0,0.3,0,0,1,0,0,1,0,0,0.7,0,0,1 3 | 2,1,1,1,0,0,1,1,0.5,1,1,0.2,0,1,1,1 4 | 3,0.8,1,1,0,0,1,1,1,1,0,0.2,1,1,1,1 5 | 4,1,0,1,1,0.6,1,1,1,1,0,0,1,0,0,1 6 | 5,1,1,0.6,0.6,0,0,1,1,1,0,0,0.8,1,1,1 7 | 6,0.5,1,1,1,0,0,1,0.7,1,1,0.7,1,1,0.8,1 8 | 7,1,1,0.2,0,0,1,0.3,0,1,0,0,1,0,0,1 9 | 8,1,1,1,0.5,0,1,1,1,1,1,0,1,1,0.6,1 10 | 9,1,1,1,1,0,1,0.4,1,1,0,0,1,1,1,0.3 11 | -------------------------------------------------------------------------------- /neuralmaster/6/Neuron_2_number_sigma.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import numpy as np" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 2, 17 | "metadata": { 18 | "collapsed": true 19 | }, 20 | "outputs": [], 21 | "source": [ 22 | "# Загрузить и подготовить тренировочные данные из формата CSV в список\n", 23 | "training_data = open(\"dataset/Data_train.csv\", 'r') # 'r' - открываем файл для чтения\n", 24 | "training_data_list = training_data.readlines() # readlines() - читает все строки в файле в переменную training_data_list\n", 25 | "training_data.close() # закрываем файл csv\n", 26 | "\n", 27 | "# Загрузить и подготовить тестовые данные из формата CSV в список\n", 28 | "test_data = open(\"dataset/Data_test.csv\", 'r') # 'r' - открываем файл для чтения\n", 29 | "test_data_list = test_data.readlines()# Загрузить и подготовить тестовые данные из формата CSV в список \n", 30 | "test_data.close() # закрываем файл csv" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 3, 36 | "metadata": { 37 | "collapsed": true 38 | }, 39 | "outputs": [], 40 | "source": [ 41 | "# Определение класса нейронной сети\n", 42 | "class neuron_Net:\n", 43 | " \n", 44 | " # Инициализация весов нейронной сети\n", 45 | " def __init__(self, input_num, neuron_num, learningrate): #констр.(кол-во входов, кол-во нейронов)\n", 46 | " # МАТРИЦА ВЕСОВ\n", 47 | " # Задаем матрицу весов как случайное от -0,5 до 0,5\n", 48 | " self.weights = (np.random.rand(neuron_num, input_num) -0.5) \n", 49 | " # Задаем параметр скорости обучения\n", 50 | " self.lr = learningrate\n", 51 | " \n", 52 | " pass\n", 53 | " \n", 54 | " # Метод обучения нейронной сети\n", 55 | " def train(self, inputs_list, targets_list): # принимает (вх. список данных, ответы)\n", 56 | " # Преобразовать список входов в вертикальный массив. .T - транспонирование\n", 57 | " inputs_x = np.array(inputs_list, ndmin=2).T # матрица числа\n", 58 | " targets_Y = np.array(targets_list, ndmin=2).T # матрица ответов: какое это число\n", 59 | " \n", 60 | " # ВЫЧИСЛЕНИЕ СИГНАЛОВ\n", 61 | " # Вычислить сигналы в нейронах. Взвешенная сумма.\n", 62 | " x = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 63 | " # Вычислить сигналы, выходящие из нейрона. Функция активации - сигмоида(x)\n", 64 | " y = 1/(1+np.exp(-x)) \n", 65 | " \n", 66 | " # ВЫЧИСЛЕНИЕ ОШИБКИ\n", 67 | " # Ошибка E = -(цель - фактическое значение) \n", 68 | " E = -(targets_Y - y) \n", 69 | " \n", 70 | " # ОБНОВЛЕНИЕ ВЕСОВ\n", 71 | " # Меняем веса по каждой связи\n", 72 | " self.weights -= self.lr * np.dot((E * y * (1.0 - y)), np.transpose(inputs_x))\n", 73 | " \n", 74 | " pass\n", 75 | " \n", 76 | " # Метод прогона тестовых значений\n", 77 | " def query(self, inputs_list): # Принимает свой набор тестовых данных\n", 78 | " # Преобразовать список входов в вертикальный 2D массив. \n", 79 | " inputs_x = np.array(inputs_list, ndmin=2).T \n", 80 | " \n", 81 | " # Вычислить сигналы в нейронах. Взвешенная сумма.\n", 82 | " x = np.dot(self.weights, inputs_x)\n", 83 | " # Вычислить сигналы, выходящие из нейрона. Сигмоида(x)\n", 84 | " y = 1/(1+np.exp(-x))\n", 85 | " \n", 86 | " return y" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 4, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [ 95 | " # ЗАДАЁМ ПАРАМЕТРЫ СЕТИ\n", 96 | "# Количество входных данных, нейронов\n", 97 | "data_input = 15\n", 98 | "data_neuron = 2\n", 99 | "\n", 100 | "# Cкорость обучения\n", 101 | "learningrate = 0.1\n", 102 | "\n", 103 | "# Создать экземпляр нейронной сети\n", 104 | "n = neuron_Net(data_input, data_neuron, learningrate)" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 5, 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [ 113 | " # ОБУЧЕНИЕ\n", 114 | "# Зададим количество эпох\n", 115 | "epochs = 40000\n", 116 | "# Прогон по обучающей выборке\n", 117 | "for e in range(epochs):\n", 118 | " for i in training_data_list:\n", 119 | " # Получить входные данные числа\n", 120 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 121 | " inputs_x = np.asfarray(all_values[1:])\n", 122 | " \n", 123 | " # Получить целевое значение Y, (ответ - какое это число)\n", 124 | " targets_Y = int(all_values[0]) # перевод символов в int, 0 элемент - ответ\n", 125 | " \n", 126 | " # создать целевые выходные значения (все 0.01, кроме нужной метки, которая равна 0.99)\n", 127 | " targets_Y = np.zeros(data_neuron) + 0.01\n", 128 | " \n", 129 | " # Получить целевое значение Y, (ответ - какое это число). all_values[0] - целевая метка для этой записи\n", 130 | " if int(all_values[0]) <= 1: # цель <= 1 потому как распознаём только 2 числа, 0 и 1.\n", 131 | " targets_Y[int(all_values[0])] = 0.99\n", 132 | " \n", 133 | " n.train(inputs_x, targets_Y) # наш метод train - обучение нейронной сети " 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": 6, 139 | "metadata": {}, 140 | "outputs": [ 141 | { 142 | "name": "stdout", 143 | "output_type": "stream", 144 | "text": [ 145 | "Весовые коэффициенты:\n", 146 | " [[ 0.55376239 -0.2659114 -0.55801795 1.63794241 -0.39180754 0.18253672\n", 147 | " -1.86935497 -4.51957151 -1.10400713 3.68316632 -1.31690796 0.48928634\n", 148 | " 0.63951451 0.6593403 -3.74255197]\n", 149 | " [-4.18510101 -3.35072555 -0.15142484 -0.89959198 -0.54914752 1.80364436\n", 150 | " -2.10131379 -0.79061126 0.94477939 0.27198919 -0.42900452 0.13232677\n", 151 | " -0.54182952 0.16586589 1.24938759]]\n" 152 | ] 153 | } 154 | ], 155 | "source": [ 156 | "# Вывод обученных весов\n", 157 | "print('Весовые коэффициенты:\\n', n.weights)" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": 7, 163 | "metadata": {}, 164 | "outputs": [ 165 | { 166 | "name": "stdout", 167 | "output_type": "stream", 168 | "text": [ 169 | "0 Вероятность:\n", 170 | " [[ 0.98282717]\n", 171 | " [ 0.0018778 ]]\n", 172 | "1 Вероятность:\n", 173 | " [[ 0.01110791]\n", 174 | " [ 0.98279182]]\n", 175 | "2 Вероятность:\n", 176 | " [[ 0.01280932]\n", 177 | " [ 0.00169931]]\n", 178 | "3 Вероятность:\n", 179 | " [[ 4.97172575e-05]\n", 180 | " [ 2.29715820e-03]]\n", 181 | "4 Вероятность:\n", 182 | " [[ 0.00010462]\n", 183 | " [ 0.0130299 ]]\n", 184 | "5 Вероятность:\n", 185 | " [[ 0.00018235]\n", 186 | " [ 0.00010789]]\n", 187 | "6 Вероятность:\n", 188 | " [[ 0.01247943]\n", 189 | " [ 0.00070262]]\n", 190 | "7 Вероятность:\n", 191 | " [[ 0.01036096]\n", 192 | " [ 0.01685072]]\n", 193 | "8 Вероятность:\n", 194 | " [[ 0.00498377]\n", 195 | " [ 0.00085023]]\n", 196 | "9 Вероятность:\n", 197 | " [[ 0.01543393]\n", 198 | " [ 0.00064968]]\n" 199 | ] 200 | } 201 | ], 202 | "source": [ 203 | "# Еще раз пройдем по обучающей выборке\n", 204 | "for i in training_data_list:\n", 205 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 206 | " inputs_x = np.asfarray(all_values[1:])\n", 207 | " # Прогон по сети\n", 208 | " outputs = n.query(inputs_x)\n", 209 | " print(i[0], 'Вероятность:\\n', outputs)" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": 8, 215 | "metadata": {}, 216 | "outputs": [ 217 | { 218 | "name": "stdout", 219 | "output_type": "stream", 220 | "text": [ 221 | "0 Узнал?: Да!\n", 222 | "1 Узнал?: Да!\n", 223 | "2 Узнал?: Нет!\n", 224 | "3 Узнал?: Нет!\n", 225 | "4 Узнал?: Нет!\n", 226 | "5 Узнал?: Нет!\n", 227 | "6 Узнал?: Нет!\n", 228 | "7 Узнал?: Нет!\n", 229 | "8 Узнал?: Нет!\n", 230 | "9 Узнал?: Нет!\n" 231 | ] 232 | } 233 | ], 234 | "source": [ 235 | "# Если вероятность больше 0,5 и номер выхода совпадает с ответом, то считаем что сеть, \n", 236 | "#на своем определенном выходе, узнала цифру. \n", 237 | "for i in training_data_list:\n", 238 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 239 | " inputs_x = np.asfarray(all_values[1:])\n", 240 | " # Прогон по сети\n", 241 | " outputs = n.query(inputs_x)\n", 242 | " # индекс самого высокого значения соответствует метке\n", 243 | " label = np.argmax(outputs)\n", 244 | " if outputs[label]>0.5 and int(all_values[0]) == label:\n", 245 | " print(i[0], 'Узнал?: ', 'Да!')\n", 246 | " else:\n", 247 | " print(i[0], 'Узнал?: ', 'Нет!') " 248 | ] 249 | }, 250 | { 251 | "cell_type": "code", 252 | "execution_count": 9, 253 | "metadata": {}, 254 | "outputs": [ 255 | { 256 | "name": "stdout", 257 | "output_type": "stream", 258 | "text": [ 259 | "Вероятность что узнал 0 - 1 ? [ 0.95590294]\n", 260 | "Вероятность что узнал 0 - 2 ? [ 0.98378171]\n", 261 | "Вероятность что узнал 0 - 3 ? [ 0.63522571]\n", 262 | "Вероятность что узнал 0 - 4 ? [ 0.92786908]\n", 263 | "Вероятность что узнал 0 - 5 ? [ 0.78988343]\n", 264 | "Вероятность что узнал 0 - 6 ? [ 0.76715129]\n", 265 | "Вероятность что узнал 1 - 1 ? [ 0.98163393]\n", 266 | "Вероятность что узнал 1 - 2 ? [ 0.98125632]\n", 267 | "Вероятность что узнал 1 - 3 ? [ 0.94877843]\n", 268 | "Вероятность что узнал 1 - 4 ? [ 0.95536855]\n", 269 | "Вероятность что узнал 1 - 5 ? [ 0.9817356]\n", 270 | "Вероятность что узнал 1 - 6 ? [ 0.95543842]\n" 271 | ] 272 | } 273 | ], 274 | "source": [ 275 | "# Проход по тестовой выборке\n", 276 | "t = 0 # Счетчик номера нуля тестовой выборки\n", 277 | "t1 = 0 # Счетчик номера единицы тестовой выборки\n", 278 | "for i in test_data_list:\n", 279 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 280 | " inputs_x = np.asfarray(all_values[1:])\n", 281 | " t += 1\n", 282 | " # Прогон по сети\n", 283 | " outputs = n.query(inputs_x)\n", 284 | " # индекс самого высокого значения соответствует метке\n", 285 | " label = np.argmax(outputs)\n", 286 | " if t <= 6:\n", 287 | " print('Вероятность что узнал 0 -',t, '?', outputs[label])\n", 288 | " else:\n", 289 | " t1 += 1\n", 290 | " print('Вероятность что узнал 1 -',t1, '?', outputs[label])" 291 | ] 292 | }, 293 | { 294 | "cell_type": "code", 295 | "execution_count": 10, 296 | "metadata": {}, 297 | "outputs": [ 298 | { 299 | "name": "stdout", 300 | "output_type": "stream", 301 | "text": [ 302 | "0 Узнал?: 1 Да!\n", 303 | "0 Узнал?: 2 Да!\n", 304 | "0 Узнал?: 3 Да!\n", 305 | "0 Узнал?: 4 Да!\n", 306 | "0 Узнал?: 5 Да!\n", 307 | "0 Узнал?: 6 Да!\n", 308 | "1 Узнал?: 7 Да!\n", 309 | "1 Узнал?: 8 Да!\n", 310 | "1 Узнал?: 9 Да!\n", 311 | "1 Узнал?: 10 Да!\n", 312 | "1 Узнал?: 11 Да!\n", 313 | "1 Узнал?: 12 Да!\n" 314 | ] 315 | } 316 | ], 317 | "source": [ 318 | "t = 0 # Счетчик номера нуля тестовой выборки\n", 319 | "t1 = 0 # Счетчик номера единицы тестовой выборки\n", 320 | "# Если вероятность больше 0,5 и номер выхода совпадает с ответом, то считаем что сеть, \n", 321 | "#на своем определенном выходе, узнала цифру. \n", 322 | "for i in test_data_list:\n", 323 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 324 | " inputs_x = np.asfarray(all_values[1:])\n", 325 | " # Прогон по сети\n", 326 | " outputs = n.query(inputs_x)\n", 327 | " # индекс самого высокого значения соответствует метке\n", 328 | " label = np.argmax(outputs)\n", 329 | " t += 1\n", 330 | " if outputs[label]>0.5 and int(all_values[0]) == label:\n", 331 | " print(i[0], 'Узнал?:',t, 'Да!')\n", 332 | " else:\n", 333 | " t1 += 1\n", 334 | " print(i[0], 'Узнал?:',t1, 'Нет!')" 335 | ] 336 | }, 337 | { 338 | "cell_type": "code", 339 | "execution_count": null, 340 | "metadata": { 341 | "collapsed": true 342 | }, 343 | "outputs": [], 344 | "source": [] 345 | } 346 | ], 347 | "metadata": { 348 | "kernelspec": { 349 | "display_name": "Python 3", 350 | "language": "python", 351 | "name": "python3" 352 | }, 353 | "language_info": { 354 | "codemirror_mode": { 355 | "name": "ipython", 356 | "version": 3 357 | }, 358 | "file_extension": ".py", 359 | "mimetype": "text/x-python", 360 | "name": "python", 361 | "nbconvert_exporter": "python", 362 | "pygments_lexer": "ipython3", 363 | "version": "3.6.3" 364 | } 365 | }, 366 | "nbformat": 4, 367 | "nbformat_minor": 2 368 | } 369 | -------------------------------------------------------------------------------- /neuralmaster/6/dataset/Data_test.csv: -------------------------------------------------------------------------------- 1 | 0,1,0.5,1,1,0,1,1,0,1,0.7,0,1,1,1,0 2 | 0,1,1,1,0.9,0,1,1,0,0.8,1,0,1,1,1,0 3 | 0,1,1,1,0.4,0,1,1,0,1,1,0,1,0,1,0.5 4 | 0,0,1,0.2,1,0,1,1,0,1,1,0,1,1,0.6,0.3 5 | 0,1,0.6,1,1,0,1,1,0,0,1,0,1,0.7,1,1 6 | 0,1,1,1,0.4,0,1,0,0,1,1,0,1,1,1,1 7 | 1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1 8 | 1,0,0,0.7,0,0,1,0,0,1,0,0,0.5,0,0,1 9 | 1,0.2,0,1,0,0,1,0,0,1,0.1,0,1,0,0,0.8 10 | 1,0,0,1,0,0,0.5,0,0,1,0,0,0.9,0,0,1 11 | 1,0,0,0.6,0,0.1,1,0,0,1,0,0,1,0,0,1 12 | 1,0.1,0,1,0,0,0.8,0,0,0.9,0,0,0.7,0,0,1 13 | -------------------------------------------------------------------------------- /neuralmaster/6/dataset/Data_train.csv: -------------------------------------------------------------------------------- 1 | 0,1,1,1,1,0,1,0.4,0,1,1,0,1,1,1,0.3 2 | 1,0,0,0.3,0,0,1,0,0,1,0,0,0.7,0,0,1 3 | 2,1,1,1,0,0,1,1,0.5,1,1,0.2,0,1,1,1 4 | 3,0.8,1,1,0,0,1,1,1,1,0,0.2,1,1,1,1 5 | 4,1,0,1,1,0.6,1,1,1,1,0,0,1,0,0,1 6 | 5,1,1,0.6,0.6,0,0,1,1,1,0,0,0.8,1,1,1 7 | 6,0.5,1,1,1,0,0,1,0.7,1,1,0.7,1,1,0.8,1 8 | 7,1,1,0.2,0,0,1,0.3,0,1,0,0,1,0,0,1 9 | 8,1,1,1,0.5,0,1,1,1,1,1,0,1,1,0.6,1 10 | 9,1,1,1,1,0,1,0.4,1,1,0,0,1,1,1,0.3 11 | -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/7Recognize_MNIST.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import numpy as np\n", 12 | "# библиотека для вывода на консоль массивов\n", 13 | "import matplotlib.pyplot\n", 14 | "# убедитесь, что участки находятся внутри этой записной книжки, а не внешнего окна\n", 15 | "%matplotlib inline\n", 16 | "#plt.show() # Вместо %matplotlib inline в других средах, не notebook\n", 17 | "from time import time, sleep #Для замера времени выполнения функций\n", 18 | "from tqdm import tqdm #Для вывода прогресса вычисления функций\n", 19 | "# glob помогает выбрать несколько файлов, используя шаблоны\n", 20 | "import glob\n", 21 | "# помощник для загрузки данных из файлов изображений PNG\n", 22 | "import scipy.misc" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": 2, 28 | "metadata": { 29 | "collapsed": true 30 | }, 31 | "outputs": [], 32 | "source": [ 33 | "# Загрузить mnist тренировочные данные в формате CSV \n", 34 | "training_data_file = open(\"MNIST_dataset/mnist_train.csv\", 'r') # 'r' - открываем файл для чтения\n", 35 | "training_data_list = training_data_file.readlines() # readlines() - читает все строки в файле в переменную training_data_list\n", 36 | "training_data_file.close() # закрываем фаел csv" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 3, 42 | "metadata": { 43 | "collapsed": true 44 | }, 45 | "outputs": [], 46 | "source": [ 47 | "# Определение класса нейронной сети\n", 48 | "class neuron_Net:\n", 49 | " \n", 50 | " \n", 51 | " # Инициализация весов нейронной сети\n", 52 | " def __init__(self, input_num, neuron_num, output_num, learningrate): #констр.(входной слой, скрытый слой, выходной слой)\n", 53 | " # МАТРИЦЫ ВЕСОВ\n", 54 | " # Задаем матрицы весов как случайное\n", 55 | " self.weights = np.random.normal(0.0, pow(input_num, -0.5), (neuron_num, input_num))\n", 56 | " self.weights_out = np.random.normal(0.0, pow(neuron_num, -0.5), (output_num, neuron_num))\n", 57 | " # Можно задать веса таким образом\n", 58 | " #self.weights = (numpy.random.rand(neuron_num, input_num) -0.5) \n", 59 | " #self.weights_out = (numpy.random.rand(output_num, neuron_num) -0.5)\n", 60 | "\n", 61 | " # скорость обучения\n", 62 | " self.lr = learningrate\n", 63 | " \n", 64 | " pass\n", 65 | "\n", 66 | " \n", 67 | " # Обучение нейронной сети\n", 68 | " def train(self, inputs_list, targets_list): # принемает входной список данных,targets ответы\n", 69 | " # Преобразовать список входов и ответов в вертикальный массив. .T - транспонирование\n", 70 | " inputs_x = np.array(inputs_list, ndmin=2).T # матрица числа\n", 71 | " targets_Y = np.array(targets_list, ndmin=2).T # матрица ответов какое это число\n", 72 | " \n", 73 | " # ВЫЧИСЛЕНИЕ СИГНАЛОВ ПО СЛОЯМ\n", 74 | " # Вычислить сигналы в нейронах скрытого слоя. Взвешенная сумма.\n", 75 | " x1 = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 76 | " \n", 77 | " # вычислить сигналы, возникающие из скрытого слоя. сигмоида(Xhidden - сигнал скр.слоя)\n", 78 | " y1 = 1/(1+np.exp(-x1))\n", 79 | " \n", 80 | " # вычислить сигналы в окончательном выходном слое (матрица сигналов выходного слоя)\n", 81 | " x2 = np.dot(self.weights_out, y1) \n", 82 | " # вычислить сигналы, исходящие из конечного выходного слоя. сигмоида(Xoutputs - сигнал вых.слоя)\n", 83 | " y2 = 1/(1+np.exp(-x2))\n", 84 | " \n", 85 | " # ВЫЧИСЛЕНИЕ ОШИБКИ ПО СЛОЯМ\n", 86 | " # Ошибка выходного слоя E = -(цель - фактическое значение) \n", 87 | " E = -(targets_Y - y2)\n", 88 | " # Ошибка скрытого слоя\n", 89 | " E_hidden = np.dot(self.weights_out.T, E) \n", 90 | " \n", 91 | " # ОБНОВЛЕНИЕ ВЕСОВ ПО СЛОЯМ\n", 92 | " # Меняем веса исходящие из скрытого слоя по каждой связи\n", 93 | " self.weights_out -= self.lr * np.dot((E * y2 * (1.0 - y2)), np.transpose(y1))\n", 94 | " \n", 95 | " # Меняем веса исходящие из входного слоя по каждой связи\n", 96 | " self.weights -= self.lr * np.dot((E_hidden * y1 * (1.0 - y1)), np.transpose(inputs_x))\n", 97 | " \n", 98 | " pass\n", 99 | "\n", 100 | " # МЕТОД ПРОГОНА СВОИХ ЗНАЧЕНИЙ ПО СЕТИ\n", 101 | " # Метод прогона тестовых значений\n", 102 | " def query(self, inputs_list): # Принимает свой набор тестовых данных\n", 103 | " # Преобразовать список входов в вертикальный массив. \n", 104 | " inputs_x = np.array(inputs_list, ndmin=2).T \n", 105 | " \n", 106 | " # Вычислить сигналы в нейронах скрытого слоя. Взвешенная сумма.\n", 107 | " x1 = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 108 | " # Вычислить сигналы, выходящие из нейрона. Функция активации - сигмоида(x)\n", 109 | " y1 = 1/(1+np.exp(-x1))\n", 110 | " # Вычислить сигналы в нейронах выходного слоя. Взвешенная сумма.\n", 111 | " x2 = np.dot(self.weights_out, y1) \n", 112 | " # вычислить сигналы, исходящие из конечного выходного слоя. Функция активации - сигмоида(x)\n", 113 | " y2 = 1/(1+np.exp(-x2))\n", 114 | " \n", 115 | " return y2 " 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": 4, 121 | "metadata": { 122 | "collapsed": true 123 | }, 124 | "outputs": [], 125 | "source": [ 126 | " # ЗАДАЁМ ПАРАМЕТРЫ СЕТИ\n", 127 | "# Количество входных данных, нейронов\n", 128 | "data_input = 784\n", 129 | "data_neuron = 220\n", 130 | "data_output = 10\n", 131 | "\n", 132 | "# Cкорость обучения\n", 133 | "learningrate = 0.15\n", 134 | "\n", 135 | "# Создать экземпляр нейронной сети\n", 136 | "n = neuron_Net(data_input, data_neuron, data_output, learningrate)" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 5, 142 | "metadata": {}, 143 | "outputs": [ 144 | { 145 | "name": "stderr", 146 | "output_type": "stream", 147 | "text": [ 148 | "1: 100%|████████████████████████████████████████████████████████████████████████| 60000/60000 [01:36<00:00, 621.06it/s]\n", 149 | "2: 100%|████████████████████████████████████████████████████████████████████████| 60000/60000 [01:35<00:00, 629.37it/s]\n", 150 | "3: 100%|████████████████████████████████████████████████████████████████████████| 60000/60000 [01:35<00:00, 627.15it/s]\n" 151 | ] 152 | }, 153 | { 154 | "name": "stdout", 155 | "output_type": "stream", 156 | "text": [ 157 | "Время выполнения: 287.62470269203186 сек\n" 158 | ] 159 | } 160 | ], 161 | "source": [ 162 | " # ОБУЧЕНИЕ\n", 163 | "# Зададим количество эпох\n", 164 | "epochs = 3\n", 165 | "\n", 166 | "start = time()\n", 167 | "# Прогон по обучающей выборке\n", 168 | "for e in range(epochs):\n", 169 | " # Пройдите все записи в наборе тренировочных данных \n", 170 | " #for record in training_data_list:\n", 171 | " for i in tqdm(training_data_list, desc = str(e+1)): # tqdm - используем интерактив состояния прогресса вычисления\n", 172 | " # Получить входные данные числа\n", 173 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 174 | " # Массив данных входа с масштабированием от 0,01 до 0,99\n", 175 | " inputs_x = (np.asfarray(all_values[1:])/ 255.0 * 0.99) + 0.01 # Игнорируем нулевой индекс, где целевое значение\n", 176 | " \n", 177 | " # Получить целевое значение Y, (ответ - какое это число)\n", 178 | " targets_Y = int(all_values[0]) # перевод символов в int, 0 элемент - целевое значение\n", 179 | " \n", 180 | " # создать целевые выходные значения (все 0.01, кроме нужной метки, которая равна 0.99)\n", 181 | " targets_Y = np.zeros(data_output) + 0.01\n", 182 | " \n", 183 | " # Получить целевое значение Y, (ответ - какое это число). all_values[0] - целевая метка для этой записи\n", 184 | " targets_Y[int(all_values[0])] = 0.99\n", 185 | " \n", 186 | " n.train(inputs_x, targets_Y) # наш метод train - обучение нейронной сети\n", 187 | " \n", 188 | " pass\n", 189 | " pass\n", 190 | "\n", 191 | "time_out = time() - start\n", 192 | "print(\"Время выполнения: \", time_out, \" сек\" )" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": 6, 198 | "metadata": { 199 | "collapsed": true 200 | }, 201 | "outputs": [], 202 | "source": [ 203 | " # ТЕСТИРОВАНИЕ ОБУЧЕННОЙ СЕТИ\n", 204 | "# Загрузить тестовый CSV-файл\n", 205 | "test_data_file = open(\"MNIST_dataset/mnist_test.csv\", 'r') # 'r' - открываем файл для чтения\n", 206 | "test_data_list = test_data_file.readlines() # readlines() - читает все строки в файле в переменную test_data_list\n", 207 | "test_data_file.close() # закрываем файл csv" 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": 7, 213 | "metadata": { 214 | "collapsed": true 215 | }, 216 | "outputs": [], 217 | "source": [ 218 | " # ПРОВЕРКА ЭФФЕКТИВНОСТИ НЕЙРОННОЙ СЕТИ\n", 219 | "# Массив показателей эффективности сети, изначально пустой\n", 220 | "efficiency = []\n", 221 | "\n", 222 | "# Прогон по всем записям в наборе тестовых данных\n", 223 | "for i in test_data_list:\n", 224 | " # Получить входные данные числа \n", 225 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 226 | " # Правильный ответ, хранимый в нулевом индексе\n", 227 | " targets_Y = int(all_values[0])\n", 228 | " # Массив данных входа с масштабированием от 0,01 до 0,99\n", 229 | " inputs_x = (np.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01 # Игнорируем нулевой индекс, где целевое значение\n", 230 | "\n", 231 | " # Запросить ответ у сети\n", 232 | " outputs_y = n.query(inputs_x) # Прогон по сети тестового значения из нашего файла\n", 233 | " # Индекс самого высокого значения на матрице выхода, соответствует метке числа\n", 234 | " label_y = np.argmax(outputs_y) # argmax возвращает индекс максимального элемента в выходном массиве\n", 235 | " \n", 236 | " # Добавить правильный или неправильный список\n", 237 | " if (label_y == targets_Y): # Если индекс макс. знач. на выходе = целевому значению (0 индекс массива данных)\n", 238 | " # Если ответ сети соответствует целевому значению, добавляем 1 в конец массива показателей эффективности\n", 239 | " efficiency.append(1)\n", 240 | " else:\n", 241 | " # Если ответ сети не соответствует целевому значению, добавляем 0 в конец массива показателей эффективности\n", 242 | " efficiency.append(0)\n", 243 | " \n", 244 | " pass\n", 245 | " \n", 246 | " pass" 247 | ] 248 | }, 249 | { 250 | "cell_type": "code", 251 | "execution_count": 8, 252 | "metadata": {}, 253 | "outputs": [ 254 | { 255 | "name": "stdout", 256 | "output_type": "stream", 257 | "text": [ 258 | "Производительность = 97.09 %\n" 259 | ] 260 | } 261 | ], 262 | "source": [ 263 | "# Вычислить оценку производительности. Доля правильных ответов\n", 264 | "efficiency_map = np.asarray(efficiency) # asarray - преобразование списка в массив \n", 265 | "\n", 266 | "print ('Производительность = ', (efficiency_map.sum() / efficiency_map.size)*100, '%') # Среднее арифметическое " 267 | ] 268 | }, 269 | { 270 | "cell_type": "code", 271 | "execution_count": 57, 272 | "metadata": {}, 273 | "outputs": [ 274 | { 275 | "name": "stdout", 276 | "output_type": "stream", 277 | "text": [ 278 | "Имя файла: my_image\\_my_0.png\n" 279 | ] 280 | }, 281 | { 282 | "name": "stderr", 283 | "output_type": "stream", 284 | "text": [ 285 | "D:\\Anaconda_3\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:15: DeprecationWarning: `imread` is deprecated!\n", 286 | "`imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n", 287 | "Use ``imageio.imread`` instead.\n", 288 | " from ipykernel import kernelapp as app\n" 289 | ] 290 | }, 291 | { 292 | "name": "stdout", 293 | "output_type": "stream", 294 | "text": [ 295 | "Имя файла: my_image\\_my_1.png\n", 296 | "Имя файла: my_image\\_my_2.png\n", 297 | "Имя файла: my_image\\_my_3.png\n", 298 | "Имя файла: my_image\\_my_4.png\n", 299 | "Имя файла: my_image\\_my_5.png\n", 300 | "Имя файла: my_image\\_my_6.png\n", 301 | "Имя файла: my_image\\_my_7.png\n", 302 | "Имя файла: my_image\\_my_8.png\n" 303 | ] 304 | } 305 | ], 306 | "source": [ 307 | " # СОБСТВЕННЫЙ НАБОР ИЗОБРАЖЕНИЙ ДЛЯ ТЕСТА\n", 308 | "my_dataset = [] # Для хранения данных и целевых значений \n", 309 | "\n", 310 | "# Загрузить данные изображения в формате PNG, как установить тестовые данные\n", 311 | "for image_file in glob.glob('my_image/_my_?.png'): # проход по файлам изобр. в папке my_images\n", 312 | " #glob - из библиотеки glob, помогает выбрать сразу несколько файлов из папки\n", 313 | " \n", 314 | " # Метка имени числа\n", 315 | " label_y = int(image_file[-5:-4]) # хранит число в файле ?.png, -5 это ответ какое число '?'\n", 316 | " # от -5 до -4 это будет символ '?', т.е метка числа\n", 317 | " \n", 318 | " # Загрузить данные изображения из png файлов в массив\n", 319 | " print ('Имя файла: ', image_file) # вывод пути и имени открытого файла\n", 320 | " \n", 321 | " image_list = scipy.misc.imread(image_file, flatten=True) #“flatten=True” (“выровнять=True) ”- превращает\n", 322 | " #изображения в простой массив чисел с плавающей запятой\n", 323 | " \n", 324 | " # Изменить формат из 28x28 в список 784 значений, инвертировать значения\n", 325 | " image_data = 255.0 - image_list.reshape(784) #преобразует массив из квадрата 28x28 в длинный список значений\n", 326 | " #вычитание значений массива из 255.0. т.к обычно '0' означает черное, а '255' означает белое, но набор данных MNIST \n", 327 | " #имеет инверсные значения, поэтому мы должны их перевернуть\n", 328 | " \n", 329 | " # Вносим данные шкалу с диапазоном от 0 до 1\n", 330 | " image_data = (image_data / 255.0 ) # массив данных входа с масштабированием от 0 до 1 \n", 331 | " \n", 332 | " # Добавить метку числа и данные изображения к общему набору данных\n", 333 | " my_data = np.append(label_y, image_data)\n", 334 | " my_dataset.append(my_data) \n", 335 | " \n", 336 | " pass" 337 | ] 338 | }, 339 | { 340 | "cell_type": "code", 341 | "execution_count": 60, 342 | "metadata": { 343 | "scrolled": true 344 | }, 345 | "outputs": [ 346 | { 347 | "name": "stdout", 348 | "output_type": "stream", 349 | "text": [ 350 | "[[ 6.66671197e-01]\n", 351 | " [ 2.56659427e-03]\n", 352 | " [ 9.32429328e-03]\n", 353 | " [ 6.77700446e-05]\n", 354 | " [ 1.92683835e-03]\n", 355 | " [ 2.02324562e-03]\n", 356 | " [ 3.13702331e-03]\n", 357 | " [ 8.52300221e-03]\n", 358 | " [ 2.36677373e-04]\n", 359 | " [ 4.81128855e-03]]\n", 360 | "Минимальное значение: 6.77700445779e-05\n", 361 | "Максимальное значение: 0.666671197018\n", 362 | "\n", 363 | "Целевое значение: 0\n", 364 | "Угадал!!! :-)))\n" 365 | ] 366 | }, 367 | { 368 | "data": { 369 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", 370 | "text/plain": [ 371 | "" 372 | ] 373 | }, 374 | "metadata": {}, 375 | "output_type": "display_data" 376 | } 377 | ], 378 | "source": [ 379 | " # ПРОВЕРКА СЕТИ НА СОБСТВЕННЫХ ДАННЫХ ИЗОБРАЖЕНИЙ\n", 380 | "\n", 381 | "# запись для тестирования\n", 382 | "room_choices = 0\n", 383 | "\n", 384 | "# Изображение участка\n", 385 | "matplotlib.pyplot.imshow(my_dataset[room_choices][1:].reshape(28,28), cmap='Greys', interpolation='None')\n", 386 | "# my_dataset- наш собственный набор тестовых данных\n", 387 | "\n", 388 | "# Правильный ответ в нулевом столбце\n", 389 | "correct_label = my_dataset[room_choices][0] # в строках номер файла из папки собственных данных, 0 толбец - ответ какое число\n", 390 | "\n", 391 | "# Входные значения\n", 392 | "input_x = my_dataset[room_choices][1:] # значение числа без ответа\n", 393 | "\n", 394 | "# Запросить сеть\n", 395 | "output_y = n.query(input_x) # прогоняем тестовую выборку по сети\n", 396 | "print (output_y) # вывод по выходу сети\n", 397 | "\n", 398 | "print('Минимальное значение: ', np.min(output_y)) # вывод мин знач элемента на выходе\n", 399 | "print('Максимальное значение: ', np.max(output_y)) # вывод макс знач элемента на выходе\n", 400 | "\n", 401 | "# Индекс самого высокого значения на выходе сети, соответствует метке\n", 402 | "number = np.argmax(output_y)\n", 403 | "print('\\nЦелевое значение: ', number)\n", 404 | "\n", 405 | "# Вывод правильный или неправильный ответ\n", 406 | "if (number == correct_label): # если макс знач на выходе label = ответу (0 индекс из массива) correct_label\n", 407 | " print ('Угадал!!! :-)))') \n", 408 | "else:\n", 409 | " print ('Не угадал! :-(((') \n", 410 | " \n", 411 | " pass" 412 | ] 413 | }, 414 | { 415 | "cell_type": "code", 416 | "execution_count": null, 417 | "metadata": { 418 | "collapsed": true 419 | }, 420 | "outputs": [], 421 | "source": [] 422 | } 423 | ], 424 | "metadata": { 425 | "kernelspec": { 426 | "display_name": "Python 3", 427 | "language": "python", 428 | "name": "python3" 429 | }, 430 | "language_info": { 431 | "codemirror_mode": { 432 | "name": "ipython", 433 | "version": 3 434 | }, 435 | "file_extension": ".py", 436 | "mimetype": "text/x-python", 437 | "name": "python", 438 | "nbconvert_exporter": "python", 439 | "pygments_lexer": "ipython3", 440 | "version": "3.6.3" 441 | } 442 | }, 443 | "nbformat": 4, 444 | "nbformat_minor": 1 445 | } 446 | -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/8Convolution_algorithms.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### ВХОДНЫЕ ДАННЫЕ:" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stdout", 17 | "output_type": "stream", 18 | "text": [ 19 | "x1: \n", 20 | " [[ 1 2 3 4]\n", 21 | " [ 5 6 7 8]\n", 22 | " [ 9 10 11 12]\n", 23 | " [13 14 15 16]] \n", 24 | "\n", 25 | "w1: \n", 26 | " [[[1 2]\n", 27 | " [3 4]]\n", 28 | "\n", 29 | " [[5 6]\n", 30 | " [7 8]]] \n", 31 | "\n" 32 | ] 33 | } 34 | ], 35 | "source": [ 36 | "import numpy as np\n", 37 | "\n", 38 | " #ВХОДНЫЕ ДАННЫЕ\n", 39 | "m = 4 #Размерность входного массива(ДхШ)\n", 40 | "k = 2 #Размерность ядра свертки (ДхШ)\n", 41 | "m_k_1 = (m-k)+1 #Размерность одной карты скрытого слоя свертки (ДхШ)\n", 42 | "stok_w = 2 #Число ядер свертки и соответственно количество карт срытого слоя (ДхШ)\n", 43 | "stob_w = k*k #Количество элементов в ядре свертки между входным и скрытым слоями\n", 44 | "\n", 45 | "x1 = np.arange(1,m*m+1).reshape(m,m) #Входной 2D массив данных\n", 46 | "w1 = np.arange(1,stok_w*stob_w+1).reshape(stok_w, k,k) #Ядра свертки (веса)\n", 47 | "x2 = np.zeros((stok_w, m_k_1, m_k_1)) #Выходной массив (карты скрытого слоя)\n", 48 | "#(s1, f1, f1) = x1.shape # Получаем размеры выходного массива\n", 49 | "(s2, f2, f2) = x2.shape # Получаем размеры выходного массива \n", 50 | "e2 = np.arange(1,s2*f2*f2+1).reshape(stok_w, m_k_1, m_k_1) #Ошибка скрытого слоя (размеры должны совпадать с картой этого слоя)\n", 51 | "lr = 0.01 #Скорость обучения \n", 52 | "print ('x1: ','\\n', x1, '\\n')\n", 53 | "print ('w1: ','\\n',w1, '\\n')" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": { 59 | "collapsed": true 60 | }, 61 | "source": [ 62 | "### СВЁРТКА:" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 2, 68 | "metadata": {}, 69 | "outputs": [ 70 | { 71 | "name": "stdout", 72 | "output_type": "stream", 73 | "text": [ 74 | "Вход x1:\n", 75 | " [[ 1 2 3 4]\n", 76 | " [ 5 6 7 8]\n", 77 | " [ 9 10 11 12]\n", 78 | " [13 14 15 16]]\n", 79 | "Вес w1:\n", 80 | " [[[1 2]\n", 81 | " [3 4]]\n", 82 | "\n", 83 | " [[5 6]\n", 84 | " [7 8]]]\n", 85 | "Сверточный слой x2:\n", 86 | " [[[ 44. 54. 64.]\n", 87 | " [ 84. 94. 104.]\n", 88 | " [ 124. 134. 144.]]\n", 89 | "\n", 90 | " [[ 100. 126. 152.]\n", 91 | " [ 204. 230. 256.]\n", 92 | " [ 308. 334. 360.]]] \n", 93 | "\n" 94 | ] 95 | } 96 | ], 97 | "source": [ 98 | " # ОПЕРАЦИЯ СВЁРТКИ\n", 99 | "print('Вход x1:\\n', x1)\n", 100 | "print('Вес w1:\\n',w1)\n", 101 | "\n", 102 | "for s in range(stok_w): # Цикл по количеству ядер свёртки\n", 103 | " for h in range(m_k_1): # Цикл по количеству проходов ядра свёртки, по горизонтали от входных данных\n", 104 | " for w in range(m_k_1): # Цикл по количеству проходов ядра свёртки, по вертикали от входных данных\n", 105 | " x2 [s,h,w] = np.sum(x1[h:h+k, w:w+k] * w1[s]) # Сумма поэлементного умножения области входных данных с ядром\n", 106 | "\n", 107 | "print('Сверточный слой x2:\\n', x2, '\\n')" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "### ОБНОВЛЕНИЕ ВЕСОВ ЯДРА СВЁРТКИ:" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": 3, 120 | "metadata": {}, 121 | "outputs": [ 122 | { 123 | "name": "stdout", 124 | "output_type": "stream", 125 | "text": [ 126 | "Вход x1:\n", 127 | " [[ 1 2 3 4]\n", 128 | " [ 5 6 7 8]\n", 129 | " [ 9 10 11 12]\n", 130 | " [13 14 15 16]]\n", 131 | "Ошибка e2:\n", 132 | " [[[ 1 2 3]\n", 133 | " [ 4 5 6]\n", 134 | " [ 7 8 9]]\n", 135 | "\n", 136 | " [[10 11 12]\n", 137 | " [13 14 15]\n", 138 | " [16 17 18]]]\n", 139 | "Обновленные веса w1:\n", 140 | " [[[ 192 237]\n", 141 | " [ 372 417]]\n", 142 | "\n", 143 | " [[ 678 804]\n", 144 | " [1182 1308]]]\n" 145 | ] 146 | } 147 | ], 148 | "source": [ 149 | "print('Вход x1:\\n', x1)\n", 150 | "print('Ошибка e2:\\n', e2)\n", 151 | "\n", 152 | "def Xrot_180(X_rot_180):\n", 153 | " #for s in range(stok_w):\n", 154 | " X_rot_180 = np.fliplr(X_rot_180)\n", 155 | " X_rot_180 = np.flipud(X_rot_180)\n", 156 | " return X_rot_180\n", 157 | "\n", 158 | "for s in range(stok_w): # Цикл по количеству ядер свёртки\n", 159 | " #for h in range(m-(m_k_1)+1): \n", 160 | " for h in range(k): # Цикл по количеству элементов ядра свёртки, по горизонтали\n", 161 | " #for w in range(m-(m_k_1)+1): \n", 162 | " for w in range(k): # Цикл по количеству элементов ядра свёртки, по вертикали\n", 163 | " w1[s, h, w] = np.sum(e2[s] * Xrot_180(x1[h:h+m_k_1, w:w+m_k_1])) # Сумма поэлементного умножения области входных данных \n", 164 | " #и ошибки скрытого слоя\n", 165 | "\n", 166 | "print('Обновленные веса w1:\\n', w1)" 167 | ] 168 | }, 169 | { 170 | "cell_type": "markdown", 171 | "metadata": {}, 172 | "source": [ 173 | "### ОБРАТНОЕ РАСПРОСТРОНЕНИЕ ОШИБКИ:" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 4, 179 | "metadata": {}, 180 | "outputs": [ 181 | { 182 | "name": "stdout", 183 | "output_type": "stream", 184 | "text": [ 185 | "Перевернутые веса rot180_w1 :\n", 186 | " [[[ 417 372]\n", 187 | " [ 237 192]]\n", 188 | "\n", 189 | " [[1308 1182]\n", 190 | " [ 804 678]]]\n", 191 | "Матрица размера - для прогона весов как показано на слайде e2_temp:\n", 192 | " [[[ 0. 0. 0. 0. 0.]\n", 193 | " [ 0. 1. 2. 3. 0.]\n", 194 | " [ 0. 4. 5. 6. 0.]\n", 195 | " [ 0. 7. 8. 9. 0.]\n", 196 | " [ 0. 0. 0. 0. 0.]]\n", 197 | "\n", 198 | " [[ 0. 0. 0. 0. 0.]\n", 199 | " [ 0. 10. 11. 12. 0.]\n", 200 | " [ 0. 13. 14. 15. 0.]\n", 201 | " [ 0. 16. 17. 18. 0.]\n", 202 | " [ 0. 0. 0. 0. 0.]]]\n", 203 | "Ошибка до суммы - e1:\n", 204 | " [[[ 2.46134113 6.28326256 10.50991501 7.11134185]\n", 205 | " [ 11.4001816 30.69002458 42.87000333 26.73000045]\n", 206 | " [ 28.32000006 67.23000001 79.41 46.35 ]\n", 207 | " [ 26.04 58.95 66.84 37.53 ]]\n", 208 | "\n", 209 | " [[ 68.34134113 155.05326256 169.80991501 96.48134185]\n", 210 | " [ 206.3401816 460.26002458 499.98000333 277.56000045]\n", 211 | " [ 262.14000006 579.42000001 619.14 340.92 ]\n", 212 | " [ 189.12 410.22 435.12 235.44 ]]]\n", 213 | "Ошибка после суммы - e1:\n", 214 | " [[[ 70.80268227 161.33652511 180.31983002 103.5926837 ]\n", 215 | " [ 217.7403632 490.95004915 542.85000665 304.2900009 ]\n", 216 | " [ 290.46000012 646.65000002 698.55 387.27 ]\n", 217 | " [ 215.16 469.17 501.96 272.97 ]]\n", 218 | "\n", 219 | " [[ 68.34134113 155.05326256 169.80991501 96.48134185]\n", 220 | " [ 206.3401816 460.26002458 499.98000333 277.56000045]\n", 221 | " [ 262.14000006 579.42000001 619.14 340.92 ]\n", 222 | " [ 189.12 410.22 435.12 235.44 ]]]\n", 223 | "Ошибка входного слоя - e1:\n", 224 | " [[ 70.80268227 161.33652511 180.31983002 103.5926837 ]\n", 225 | " [ 217.7403632 490.95004915 542.85000665 304.2900009 ]\n", 226 | " [ 290.46000012 646.65000002 698.55 387.27 ]\n", 227 | " [ 215.16 469.17 501.96 272.97 ]]\n" 228 | ] 229 | } 230 | ], 231 | "source": [ 232 | " # ОБРАТНОЕ РАСПРОСТРОНЕНИЕ ОШИБКИ\n", 233 | "# Функция переворота матрицы весов на 180\n", 234 | "e1 = np.zeros((stok_w, m, m)) #Ошибка входного слоя\n", 235 | "def rot_180(W_rot_180):\n", 236 | " for s in range(stok_w):\n", 237 | " W_rot_180[s] = np.fliplr(W_rot_180[s])\n", 238 | " W_rot_180[s] = np.flipud(W_rot_180[s])\n", 239 | " return W_rot_180\n", 240 | "\n", 241 | "rot180_w1 = rot_180(w1)\n", 242 | "print('Перевернутые веса rot180_w1 :\\n', rot180_w1)\n", 243 | "\n", 244 | "# Создадим матрицу размера - для прогона весов как показано на слайде\n", 245 | "e2_temp = np.zeros((stok_w, m+k-1, m+k-1))\n", 246 | "# Поместим в центр ошибку на предыдущем слое\n", 247 | "for s in range(stok_w):\n", 248 | " e2_temp[s, k-1:m_k_1+k-1, k-1:m_k_1+k-1] = e2[s] \n", 249 | "\n", 250 | "print('Матрица размера - для прогона весов как показано на слайде e2_temp:\\n', e2_temp)\n", 251 | "\n", 252 | "# Проходим по этой матрице перевернутыми ядрами\n", 253 | "for s in range(stok_w):\n", 254 | " for h in range(m):\n", 255 | " for w in range(m):\n", 256 | " #e1[s,h,w] = np.sum(lr * e2_temp[s, h:h+k, w:w+k] * rot180_w1[s])\n", 257 | " e1[s,h,w] = np.sum(lr * e2_temp[s, h:h+k, w:w+k] * rot180_w1[s] * 1/1+np.exp(-x1[h, w]) * (1 - 1/1+np.exp(-x1[h, w])))\n", 258 | "print('Ошибка до суммы - e1:\\n', e1)\n", 259 | "\n", 260 | "# Cумма ошибки (значения храним в 1м массиве)\n", 261 | "for s in range(stok_w-1):\n", 262 | " e1[0] = e1[s] + e1[s+1]\n", 263 | "print('Ошибка после суммы - e1:\\n', e1)\n", 264 | "print('Ошибка входного слоя - e1:\\n', e1[0])" 265 | ] 266 | }, 267 | { 268 | "cell_type": "markdown", 269 | "metadata": {}, 270 | "source": [ 271 | "### МАКСПУЛ:" 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": 5, 277 | "metadata": {}, 278 | "outputs": [ 279 | { 280 | "name": "stdout", 281 | "output_type": "stream", 282 | "text": [ 283 | "ПРОГОН ВПЕРЕД:\n", 284 | " \n", 285 | "Скрытый слой x22:\n", 286 | " [[[ 0 1 2 3]\n", 287 | " [ 4 5 6 7]\n", 288 | " [ 8 9 10 11]\n", 289 | " [12 13 14 15]]\n", 290 | "\n", 291 | " [[16 17 18 19]\n", 292 | " [20 21 22 23]\n", 293 | " [24 25 26 27]\n", 294 | " [28 29 30 31]]]\n", 295 | "x22_maxpool слой:\n", 296 | " [[[ 5. 7.]\n", 297 | " [ 13. 15.]]\n", 298 | "\n", 299 | " [[ 21. 23.]\n", 300 | " [ 29. 31.]]]\n", 301 | "Адрес (индекс) максимального элемента x22_el:\n", 302 | " [[['1,1' '1,3']\n", 303 | " ['3,1' '3,3']]\n", 304 | "\n", 305 | " [['1,1' '1,3']\n", 306 | " ['3,1' '3,3']]]\n", 307 | "\n", 308 | "\n", 309 | "ПРОГОН НАЗАД:\n", 310 | " \n", 311 | "Ошибка на слое пуллинга x22e_maxpool:\n", 312 | " [[[ 5. 7.]\n", 313 | " [ 13. 15.]]\n", 314 | "\n", 315 | " [[ 21. 23.]\n", 316 | " [ 29. 31.]]]\n", 317 | "Ошибка на слое перед пуллингом e1:\n", 318 | " [[[ 0. 0. 0. 0.]\n", 319 | " [ 0. 5. 0. 7.]\n", 320 | " [ 0. 0. 0. 0.]\n", 321 | " [ 0. 13. 0. 15.]]\n", 322 | "\n", 323 | " [[ 0. 0. 0. 0.]\n", 324 | " [ 0. 21. 0. 23.]\n", 325 | " [ 0. 0. 0. 0.]\n", 326 | " [ 0. 29. 0. 31.]]]\n" 327 | ] 328 | } 329 | ], 330 | "source": [ 331 | "print('ПРОГОН ВПЕРЕД:\\n ')\n", 332 | "import re # Для извлечения дробной и целой части\n", 333 | "\n", 334 | "x22 = np.arange(stok_w*m*m).reshape(stok_w,m,m) #выходной слой\n", 335 | "print('Скрытый слой x22:\\n', x22)\n", 336 | "\n", 337 | "# Пулинг данные\n", 338 | "pool_m = 2 # Размер матрицы ядра пулинга (ДхШ)\n", 339 | "m_k_1_pool = int(m/pool_m) # Размерность слоя пулинга (целая часть)\n", 340 | "x22_maxpool = np.zeros((stok_w, m_k_1_pool, m_k_1_pool)) # Матрица выходного массива пулинга\n", 341 | "x22_el = np.zeros((stok_w, m_k_1_pool, m_k_1_pool), dtype=' 0)), np.transpose(inputs_x)) # RELU\n", 97 | " \n", 98 | " pass\n", 99 | "\n", 100 | " # МЕТОД ПРОГОНА СВОИХ ЗНАЧЕНИЙ ПО СЕТИ\n", 101 | " # Метод прогона тестовых значений\n", 102 | " def query(self, inputs_list): # Принимает свой набор тестовых данных\n", 103 | " # Преобразовать список входов в вертикальный массив. \n", 104 | " inputs_x = np.array(inputs_list, ndmin=2).T \n", 105 | " \n", 106 | " # Вычислить сигналы в нейронах скрытого слоя. Взвешенная сумма.\n", 107 | " x1 = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs \n", 108 | " # вычислить сигналы, возникающие из скрытого слоя. RELU\n", 109 | " y1 = np.maximum(x1, 0) # RELU\n", 110 | " \n", 111 | " # вычислить сигналы в окончательном выходном слое (матрица сигналов выходного слоя)\n", 112 | " x2 = np.dot(self.weights_out, y1) \n", 113 | " # вычислить сигналы, исходящие из конечного выходного слоя. Softmax\n", 114 | " y2 = np.exp(x2)/np.sum(np.exp(x2), axis=0) # Softmax\n", 115 | " \n", 116 | " return y2 " 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 4, 122 | "metadata": { 123 | "collapsed": true 124 | }, 125 | "outputs": [], 126 | "source": [ 127 | " # ЗАДАЁМ ПАРАМЕТРЫ СЕТИ\n", 128 | "# Количество входных данных, нейронов\n", 129 | "data_input = 784\n", 130 | "data_neuron = 220\n", 131 | "data_output = 10\n", 132 | "\n", 133 | "# Cкорость обучения\n", 134 | "learningrate = 0.01\n", 135 | "\n", 136 | "# Создать экземпляр нейронной сети\n", 137 | "n = neuron_Net(data_input, data_neuron, data_output, learningrate)" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": 5, 143 | "metadata": {}, 144 | "outputs": [ 145 | { 146 | "name": "stderr", 147 | "output_type": "stream", 148 | "text": [ 149 | "1: 100%|████████████████████████████████████████████████████████████████████████| 60000/60000 [01:39<00:00, 601.41it/s]\n" 150 | ] 151 | }, 152 | { 153 | "name": "stdout", 154 | "output_type": "stream", 155 | "text": [ 156 | "Время выполнения: 99.77123880386353 сек\n" 157 | ] 158 | } 159 | ], 160 | "source": [ 161 | " # ОБУЧЕНИЕ\n", 162 | "# Зададим количество эпох\n", 163 | "epochs = 1\n", 164 | "\n", 165 | "start = time()\n", 166 | "# Прогон по обучающей выборке\n", 167 | "for e in range(epochs):\n", 168 | " # Пройдите все записи в наборе тренировочных данных \n", 169 | " #for record in training_data_list:\n", 170 | " for i in tqdm(training_data_list, desc = str(e+1)): # tqdm - используем интерактив состояния прогресса вычисления\n", 171 | " # Получить входные данные числа\n", 172 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 173 | " # Массив данных входа\n", 174 | " inputs_x = (np.asfarray(all_values[1:])/ 255.0) # Игнорируем нулевой индекс, где целевое значение\n", 175 | " \n", 176 | " # Получить целевое значение Y, (ответ - какое это число)\n", 177 | " targets_Y = int(all_values[0]) # перевод символов в int, 0 элемент - целевое значение\n", 178 | " \n", 179 | " # создать целевые выходные значения\n", 180 | " targets_Y = np.zeros(data_output)\n", 181 | " \n", 182 | " # Получить целевое значение Y, (ответ - какое это число). all_values[0] - целевая метка для этой записи\n", 183 | " targets_Y[int(all_values[0])] = 1\n", 184 | " \n", 185 | " n.train(inputs_x, targets_Y) # наш метод train - обучение нейронной сети\n", 186 | " \n", 187 | " pass\n", 188 | " pass\n", 189 | "\n", 190 | "time_out = time() - start\n", 191 | "print(\"Время выполнения: \", time_out, \" сек\" )" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 6, 197 | "metadata": { 198 | "collapsed": true 199 | }, 200 | "outputs": [], 201 | "source": [ 202 | " # ТЕСТИРОВАНИЕ ОБУЧЕННОЙ СЕТИ\n", 203 | "# Загрузить тестовый CSV-файл\n", 204 | "test_data_file = open(\"MNIST_dataset/mnist_test.csv\", 'r') # 'r' - открываем файл для чтения\n", 205 | "test_data_list = test_data_file.readlines() # readlines() - читает все строки в файле в переменную test_data_list\n", 206 | "test_data_file.close() # закрываем файл csv" 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": 7, 212 | "metadata": { 213 | "collapsed": true 214 | }, 215 | "outputs": [], 216 | "source": [ 217 | " # ПРОВЕРКА ЭФФЕКТИВНОСТИ НЕЙРОННОЙ СЕТИ\n", 218 | "# Массив показателей эффективности сети, изначально пустой\n", 219 | "efficiency = []\n", 220 | "\n", 221 | "# Прогон по всем записям в наборе тестовых данных\n", 222 | "for i in test_data_list:\n", 223 | " # Получить входные данные числа \n", 224 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 225 | " # Правильный ответ, хранимый в нулевом индексе\n", 226 | " targets_Y = int(all_values[0])\n", 227 | " # Массив данных входа\n", 228 | " inputs_x = (np.asfarray(all_values[1:]) / 255.0) # Игнорируем нулевой индекс, где целевое значение\n", 229 | "\n", 230 | " # Запросить ответ у сети\n", 231 | " outputs_y = n.query(inputs_x) # Прогон по сети тестового значения из нашего файла\n", 232 | " # Индекс самого высокого значения на матрице выхода, соответствует метке числа\n", 233 | " label_y = np.argmax(outputs_y) # argmax возвращает индекс максимального элемента в выходном массиве\n", 234 | " \n", 235 | " # Добавить правильный или неправильный список\n", 236 | " if (label_y == targets_Y): # Если индекс макс. знач. на выходе = целевому значению (0 индекс массива данных)\n", 237 | " # Если ответ сети соответствует целевому значению, добавляем 1 в конец массива показателей эффективности\n", 238 | " efficiency.append(1)\n", 239 | " else:\n", 240 | " # Если ответ сети не соответствует целевому значению, добавляем 0 в конец массива показателей эффективности\n", 241 | " efficiency.append(0)\n", 242 | " \n", 243 | " pass\n", 244 | " \n", 245 | " pass" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": 8, 251 | "metadata": {}, 252 | "outputs": [ 253 | { 254 | "name": "stdout", 255 | "output_type": "stream", 256 | "text": [ 257 | "Производительность = 96.01 %\n" 258 | ] 259 | } 260 | ], 261 | "source": [ 262 | "# Вычислить оценку производительности. Доля правильных ответов\n", 263 | "efficiency_map = np.asarray(efficiency) # asarray - преобразование списка в массив \n", 264 | "\n", 265 | "print ('Производительность = ', (efficiency_map.sum() / efficiency_map.size)*100, '%') # Среднее арифметическое " 266 | ] 267 | }, 268 | { 269 | "cell_type": "code", 270 | "execution_count": 9, 271 | "metadata": {}, 272 | "outputs": [ 273 | { 274 | "name": "stdout", 275 | "output_type": "stream", 276 | "text": [ 277 | "Имя файла: my_image\\_my_0.png\n" 278 | ] 279 | }, 280 | { 281 | "name": "stderr", 282 | "output_type": "stream", 283 | "text": [ 284 | "D:\\Anaconda_3\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:15: DeprecationWarning: `imread` is deprecated!\n", 285 | "`imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n", 286 | "Use ``imageio.imread`` instead.\n", 287 | " from ipykernel import kernelapp as app\n" 288 | ] 289 | }, 290 | { 291 | "name": "stdout", 292 | "output_type": "stream", 293 | "text": [ 294 | "Имя файла: my_image\\_my_1.png\n", 295 | "Имя файла: my_image\\_my_2.png\n", 296 | "Имя файла: my_image\\_my_3.png\n", 297 | "Имя файла: my_image\\_my_4.png\n", 298 | "Имя файла: my_image\\_my_5.png\n", 299 | "Имя файла: my_image\\_my_6.png\n", 300 | "Имя файла: my_image\\_my_7.png\n", 301 | "Имя файла: my_image\\_my_8.png\n" 302 | ] 303 | } 304 | ], 305 | "source": [ 306 | " # СОБСТВЕННЫЙ НАБОР ИЗОБРАЖЕНИЙ ДЛЯ ТЕСТА\n", 307 | "my_dataset = [] # Для хранения данных и целевых значений \n", 308 | "\n", 309 | "# Загрузить данные изображения в формате PNG, как установить тестовые данные\n", 310 | "for image_file in glob.glob('my_image/_my_?.png'): # проход по файлам изобр. в папке my_images\n", 311 | " #glob - из библиотеки glob, помогает выбрать сразу несколько файлов из папки\n", 312 | " \n", 313 | " # Метка имени числа\n", 314 | " label_y = int(image_file[-5:-4]) # хранит число в файле ?.png, -5 это ответ какое число '?'\n", 315 | " # от -5 до -4 это будет символ '?', т.е метка числа\n", 316 | " \n", 317 | " # Загрузить данные изображения из png файлов в массив\n", 318 | " print ('Имя файла: ', image_file) # вывод пути и имени открытого файла\n", 319 | " \n", 320 | " image_list = scipy.misc.imread(image_file, flatten=True) #“flatten=True” (“выровнять=True) ”- превращает\n", 321 | " #изображения в простой массив чисел с плавающей запятой\n", 322 | " \n", 323 | " # Изменить формат из 28x28 в список 784 значений, инвертировать значения\n", 324 | " image_data = 255.0 - image_list.reshape(784) #преобразует массив из квадрата 28x28 в длинный список значений\n", 325 | " #вычитание значений массива из 255.0. т.к обычно '0' означает черное, а '255' означает белое, но набор данных MNIST \n", 326 | " #имеет инверсные значения, поэтому мы должны их перевернуть\n", 327 | " \n", 328 | " # Вносим данные шкалу с диапазоном от 0 до 1\n", 329 | " image_data = (image_data / 255.0 ) # массив данных входа с масштабированием от 0 до 1 \n", 330 | " \n", 331 | " # Добавить метку числа и данные изображения к общему набору данных\n", 332 | " my_data = np.append(label_y, image_data)\n", 333 | " my_dataset.append(my_data) \n", 334 | " \n", 335 | " pass" 336 | ] 337 | }, 338 | { 339 | "cell_type": "code", 340 | "execution_count": 10, 341 | "metadata": { 342 | "scrolled": true 343 | }, 344 | "outputs": [ 345 | { 346 | "name": "stdout", 347 | "output_type": "stream", 348 | "text": [ 349 | "[[ 9.76867220e-01]\n", 350 | " [ 5.48636740e-05]\n", 351 | " [ 8.66427931e-04]\n", 352 | " [ 8.50829417e-05]\n", 353 | " [ 9.79160683e-06]\n", 354 | " [ 1.81606028e-02]\n", 355 | " [ 2.23624547e-03]\n", 356 | " [ 5.64872556e-04]\n", 357 | " [ 1.03415422e-03]\n", 358 | " [ 1.20738904e-04]]\n", 359 | "Минимальное значение: 9.79160683388e-06\n", 360 | "Максимальное значение: 0.976867219902\n", 361 | "\n", 362 | "Целевое значение: 0\n", 363 | "Угадал!!! :-)))\n" 364 | ] 365 | }, 366 | { 367 | "data": { 368 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", 369 | "text/plain": [ 370 | "" 371 | ] 372 | }, 373 | "metadata": {}, 374 | "output_type": "display_data" 375 | } 376 | ], 377 | "source": [ 378 | " # ПРОВЕРКА СЕТИ НА СОБСТВЕННЫХ ДАННЫХ ИЗОБРАЖЕНИЙ\n", 379 | "\n", 380 | "# запись для тестирования\n", 381 | "room_choices = 0\n", 382 | "\n", 383 | "# Изображение участка\n", 384 | "matplotlib.pyplot.imshow(my_dataset[room_choices][1:].reshape(28,28), cmap='Greys', interpolation='None')\n", 385 | "# my_dataset- наш собственный набор тестовых данных\n", 386 | "\n", 387 | "# Правильный ответ в нулевом столбце\n", 388 | "correct_label = my_dataset[room_choices][0] # в строках номер файла из папки собственных данных, 0 толбец - ответ какое число\n", 389 | "\n", 390 | "# Входные значения\n", 391 | "input_x = my_dataset[room_choices][1:] # значение числа без ответа\n", 392 | "\n", 393 | "# Запросить сеть\n", 394 | "output_y = n.query(input_x) # прогоняем тестовую выборку по сети\n", 395 | "print (output_y) # вывод по выходу сети\n", 396 | "\n", 397 | "print('Минимальное значение: ', np.min(output_y)) # вывод мин знач элемента на выходе\n", 398 | "print('Максимальное значение: ', np.max(output_y)) # вывод макс знач элемента на выходе\n", 399 | "\n", 400 | "# Индекс самого высокого значения на выходе сети, соответствует метке\n", 401 | "number = np.argmax(output_y)\n", 402 | "print('\\nЦелевое значение: ', number)\n", 403 | "\n", 404 | "# Вывод правильный или неправильный ответ\n", 405 | "if (number == correct_label): # если макс знач на выходе label = ответу (0 индекс из массива) correct_label\n", 406 | " print ('Угадал!!! :-)))') \n", 407 | "else:\n", 408 | " print ('Не угадал! :-(((') \n", 409 | " \n", 410 | " pass" 411 | ] 412 | }, 413 | { 414 | "cell_type": "code", 415 | "execution_count": null, 416 | "metadata": { 417 | "collapsed": true 418 | }, 419 | "outputs": [], 420 | "source": [] 421 | } 422 | ], 423 | "metadata": { 424 | "kernelspec": { 425 | "display_name": "Python 3", 426 | "language": "python", 427 | "name": "python3" 428 | }, 429 | "language_info": { 430 | "codemirror_mode": { 431 | "name": "ipython", 432 | "version": 3 433 | }, 434 | "file_extension": ".py", 435 | "mimetype": "text/x-python", 436 | "name": "python", 437 | "nbconvert_exporter": "python", 438 | "pygments_lexer": "ipython3", 439 | "version": "3.6.3" 440 | } 441 | }, 442 | "nbformat": 4, 443 | "nbformat_minor": 1 444 | } 445 | -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/MNIST_dataset.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CaniaCan/neuralmaster/749912721018b4ac51fc064548b83b9982ce6963/neuralmaster/7_8/MNIST/MNIST_dataset.zip -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/my_image/_my_0.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CaniaCan/neuralmaster/749912721018b4ac51fc064548b83b9982ce6963/neuralmaster/7_8/MNIST/my_image/_my_0.png -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/my_image/_my_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CaniaCan/neuralmaster/749912721018b4ac51fc064548b83b9982ce6963/neuralmaster/7_8/MNIST/my_image/_my_1.png -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/my_image/_my_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CaniaCan/neuralmaster/749912721018b4ac51fc064548b83b9982ce6963/neuralmaster/7_8/MNIST/my_image/_my_2.png -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/my_image/_my_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CaniaCan/neuralmaster/749912721018b4ac51fc064548b83b9982ce6963/neuralmaster/7_8/MNIST/my_image/_my_3.png -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/my_image/_my_4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CaniaCan/neuralmaster/749912721018b4ac51fc064548b83b9982ce6963/neuralmaster/7_8/MNIST/my_image/_my_4.png -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/my_image/_my_5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CaniaCan/neuralmaster/749912721018b4ac51fc064548b83b9982ce6963/neuralmaster/7_8/MNIST/my_image/_my_5.png -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/my_image/_my_6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CaniaCan/neuralmaster/749912721018b4ac51fc064548b83b9982ce6963/neuralmaster/7_8/MNIST/my_image/_my_6.png -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/my_image/_my_7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CaniaCan/neuralmaster/749912721018b4ac51fc064548b83b9982ce6963/neuralmaster/7_8/MNIST/my_image/_my_7.png -------------------------------------------------------------------------------- /neuralmaster/7_8/MNIST/my_image/_my_8.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CaniaCan/neuralmaster/749912721018b4ac51fc064548b83b9982ce6963/neuralmaster/7_8/MNIST/my_image/_my_8.png -------------------------------------------------------------------------------- /neuralmaster/7_8/Neuron_no_or.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import numpy as np" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 2, 17 | "metadata": { 18 | "collapsed": true 19 | }, 20 | "outputs": [], 21 | "source": [ 22 | "# Загрузить и подготовить тренировочные данные из формата CSV в список\n", 23 | "training_data = open(\"dataset/Data_train.csv\", 'r') # 'r' - открываем файл для чтения\n", 24 | "training_data_list = training_data.readlines() # readlines() - читает все строки в файле в переменную training_data_list\n", 25 | "training_data.close() # закрываем файл csv\n", 26 | "\n", 27 | "# Загрузить и подготовить тестовые данные из формата CSV в список\n", 28 | "test_data = open(\"dataset/Data_test.csv\", 'r') # 'r' - открываем файл для чтения\n", 29 | "test_data_list = test_data.readlines()# Загрузить и подготовить тестовые данные из формата CSV в список \n", 30 | "test_data.close() # закрываем файл csv" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 3, 36 | "metadata": { 37 | "collapsed": true 38 | }, 39 | "outputs": [], 40 | "source": [ 41 | "# Определение класса нейронной сети\n", 42 | "class neuron_Net:\n", 43 | " \n", 44 | " # Инициализация весов нейронной сети\n", 45 | " def __init__(self, input_num, neuron_num, learningrate): #констр.(кол-во входов, кол-во нейронов, скорость обучения)\n", 46 | " # МАТРИЦА ВЕСОВ\n", 47 | " # Задаем матрицу весов как случайное от -0,5 до 0,5\n", 48 | " self.weights = (np.random.rand(neuron_num, input_num) -0.5) \n", 49 | " # Задаем параметр скорости обучения\n", 50 | " self.lr = learningrate\n", 51 | " \n", 52 | " pass\n", 53 | " \n", 54 | " # Метод обучения нейронной сети\n", 55 | " def train(self, inputs_list, targets_list): # принимает (вх. список данных, ответы)\n", 56 | " # Преобразовать список входов в вертикальный массив. .T - транспонирование\n", 57 | " inputs_x = np.array(inputs_list, ndmin=2).T # матрица числа\n", 58 | " targets_Y = np.array(targets_list, ndmin=2).T # матрица ответов: какое это число\n", 59 | " \n", 60 | " # ВЫЧИСЛЕНИЕ СИГНАЛОВ\n", 61 | " # Вычислить сигналы в нейронах. Взвешенная сумма.\n", 62 | " x = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 63 | " # Вычислить сигналы, выходящие из нейрона. Функция активации - сигмоида(x)\n", 64 | " y = 1/(1+np.exp(-x)) \n", 65 | " \n", 66 | " # ВЫЧИСЛЕНИЕ ОШИБКИ\n", 67 | " # Ошибка E = -(цель - фактическое значение) \n", 68 | " E = -(targets_Y - y) \n", 69 | " \n", 70 | " # ОБНОВЛЕНИЕ ВЕСОВ\n", 71 | " # Меняем веса по каждой связи\n", 72 | " self.weights -= self.lr * np.dot((E * y * (1.0 - y)), np.transpose(inputs_x))\n", 73 | " \n", 74 | " pass\n", 75 | " \n", 76 | " # Метод прогона тестовых значений\n", 77 | " def query(self, inputs_list): # Принимает свой набор тестовых данных\n", 78 | " # Преобразовать список входов в вертикальный 2D массив. \n", 79 | " inputs_x = np.array(inputs_list, ndmin=2).T \n", 80 | " \n", 81 | " # Вычислить сигналы в нейронах. Взвешенная сумма.\n", 82 | " x = np.dot(self.weights, inputs_x)\n", 83 | " # Вычислить сигналы, выходящие из нейрона. Сигмоида(x)\n", 84 | " y = 1/(1+np.exp(-x))\n", 85 | " \n", 86 | " return y" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 4, 92 | "metadata": { 93 | "collapsed": true 94 | }, 95 | "outputs": [], 96 | "source": [ 97 | " # ЗАДАЁМ ПАРАМЕТРЫ СЕТИ\n", 98 | "# Количество входных данных, нейронов\n", 99 | "data_input = 2\n", 100 | "data_neuron = 2\n", 101 | "\n", 102 | "# Cкорость обучения\n", 103 | "learningrate = 0.1\n", 104 | "\n", 105 | "# Создать экземпляр нейронной сети\n", 106 | "n = neuron_Net(data_input, data_neuron, learningrate)" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 5, 112 | "metadata": { 113 | "collapsed": true 114 | }, 115 | "outputs": [], 116 | "source": [ 117 | " # ОБУЧЕНИЕ\n", 118 | "# Зададим количество эпох\n", 119 | "epochs = 10000\n", 120 | "# Прогон по обучающей выборке\n", 121 | "for e in range(epochs):\n", 122 | " for i in training_data_list:\n", 123 | " # Получить входные данные числа\n", 124 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 125 | " inputs_x = np.asfarray(all_values[1:])\n", 126 | " \n", 127 | " # Получить целевое значение Y, (ответ - какое это число)\n", 128 | " targets_Y = int(all_values[0]) # перевод символов в int, 0 элемент - ответ\n", 129 | " \n", 130 | " # создать целевые выходные значения (все 0.01, кроме нужной метки, которая равна 0.99)\n", 131 | " targets_Y = np.zeros(data_neuron) + 0.01\n", 132 | " \n", 133 | " # Получить целевое значение Y, (ответ - какое это число). all_values[0] - целевая метка для этой записи\n", 134 | " targets_Y[int(all_values[0])] = 0.99\n", 135 | " \n", 136 | " n.train(inputs_x, targets_Y) # наш метод train - обучение нейронной сети " 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 6, 142 | "metadata": {}, 143 | "outputs": [ 144 | { 145 | "name": "stdout", 146 | "output_type": "stream", 147 | "text": [ 148 | "Весовые коэффициенты:\n", 149 | " [[ 0.0082007 0.0082007]\n", 150 | " [-0.0082007 -0.0082007]]\n" 151 | ] 152 | } 153 | ], 154 | "source": [ 155 | "# Вывод обученных весов\n", 156 | "print('Весовые коэффициенты:\\n', n.weights)" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 7, 162 | "metadata": {}, 163 | "outputs": [ 164 | { 165 | "name": "stdout", 166 | "output_type": "stream", 167 | "text": [ 168 | "0 XOR 0\n", 169 | " [[ 0.5]\n", 170 | " [ 0.5]]\n", 171 | "1 XOR 0\n", 172 | " [[ 0.50205016]\n", 173 | " [ 0.49794984]]\n", 174 | "0 XOR 1\n", 175 | " [[ 0.50205016]\n", 176 | " [ 0.49794984]]\n", 177 | "1 XOR 1\n", 178 | " [[ 0.50410026]\n", 179 | " [ 0.49589974]]\n" 180 | ] 181 | } 182 | ], 183 | "source": [ 184 | "# Прогоним входные данные из обучающей выборки через обученную сеть\n", 185 | "for i in training_data_list:\n", 186 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 187 | " inputs_x = np.asfarray(all_values[1:])\n", 188 | " # Прогон по сети\n", 189 | " outputs = n.query(inputs_x)\n", 190 | " print(all_values[1], 'XOR', all_values[2], outputs)" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": { 197 | "collapsed": true 198 | }, 199 | "outputs": [], 200 | "source": [] 201 | } 202 | ], 203 | "metadata": { 204 | "kernelspec": { 205 | "display_name": "Python 3", 206 | "language": "python", 207 | "name": "python3" 208 | }, 209 | "language_info": { 210 | "codemirror_mode": { 211 | "name": "ipython", 212 | "version": 3 213 | }, 214 | "file_extension": ".py", 215 | "mimetype": "text/x-python", 216 | "name": "python", 217 | "nbconvert_exporter": "python", 218 | "pygments_lexer": "ipython3", 219 | "version": "3.6.3" 220 | } 221 | }, 222 | "nbformat": 4, 223 | "nbformat_minor": 2 224 | } 225 | -------------------------------------------------------------------------------- /neuralmaster/7_8/Neuron_no_or_1out.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import numpy as np" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 2, 17 | "metadata": { 18 | "collapsed": true 19 | }, 20 | "outputs": [], 21 | "source": [ 22 | "# Загрузить и подготовить тренировочные данные из формата CSV в список\n", 23 | "training_data = open(\"dataset/Data_train.csv\", 'r') # 'r' - открываем файл для чтения\n", 24 | "training_data_list = training_data.readlines() # readlines() - читает все строки в файле в переменную training_data_list\n", 25 | "training_data.close() # закрываем файл csv" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 3, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "# Определение класса нейронной сети\n", 37 | "class neuron_Net:\n", 38 | " \n", 39 | " # Инициализация параметров нейронной сети\n", 40 | " def __init__(self, input_num, neuron_num, output_num, learningrate):\n", 41 | " # МАТРИЦА ВЕСОВ\n", 42 | " # Задаем матрицу весов как случайное\n", 43 | " self.weights = (np.random.rand(neuron_num, input_num) +0.0)\n", 44 | " self.weights_out = (np.random.rand(output_num, neuron_num) +0.0)\n", 45 | " \n", 46 | " # Задаем параметр скорости обучения\n", 47 | " self.lr = learningrate\n", 48 | " \n", 49 | " pass\n", 50 | " \n", 51 | " # Метод обучения нейронной сети\n", 52 | " def train(self, inputs_list, targets_list): # принимает (вх. список данных, ответы)\n", 53 | " # Преобразовать список входов в вертикальный массив. .T - транспонирование\n", 54 | " inputs_x = np.array(inputs_list, ndmin=2).T # матрица числа\n", 55 | " targets_Y = np.array(targets_list, ndmin=2).T # матрица ответов\n", 56 | " \n", 57 | " # ВЫЧИСЛЕНИЕ СИГНАЛОВ\n", 58 | " # Вычислить сигналы в нейронах скрытого слоя. Взвешенная сумма.\n", 59 | " x1 = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 60 | " # Вычислить сигналы, выходящие из нейронов скрытого слоя. Функция активации - сигмоида(x)\n", 61 | " y1 = 1/(1+np.exp(-x1))\n", 62 | " # Вычислить сигналы в нейронах выходного слоя. Взвешенная сумма.\n", 63 | " x2 = np.dot(self.weights_out, y1) # dot - умножение матриц X = W*I = weights * inputs\n", 64 | " \n", 65 | " # ВЫЧИСЛЕНИЕ ОШИБКИ\n", 66 | " # Ошибка выходного слоя: E = -(цель - фактическое значение) \n", 67 | " E = -(targets_Y - x2)\n", 68 | " # Скрытая ошибка слоя\n", 69 | " E_hidden = np.dot(self.weights_out.T, E) \n", 70 | " \n", 71 | " # ОБНОВЛЕНИЕ ВЕСОВ\n", 72 | " # Меняем веса связей, исходящих из скрытого слоя\n", 73 | " self.weights_out -= self.lr * np.dot((E * x2), np.transpose(y1))\n", 74 | " # Меняем веса связей, исходящих из входного слоя\n", 75 | " self.weights -= self.lr * np.dot((E_hidden * y1 * (1.0 - y1)), np.transpose(inputs_x))\n", 76 | " \n", 77 | " pass\n", 78 | " \n", 79 | " # Метод прогона тестовых значений\n", 80 | " def query(self, inputs_list): # Принимает свой набор тестовых данных\n", 81 | " # Преобразовать список входов в вертикальный 2D массив. \n", 82 | " inputs_x = np.array(inputs_list, ndmin=2).T \n", 83 | " \n", 84 | " # Вычислить сигналы в нейронах скрытого слоя. Взвешенная сумма.\n", 85 | " x1 = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 86 | " # Вычислить сигналы, выходящие из нейронов скрытого слоя. Функция активации - сигмоида(x)\n", 87 | " y1 = 1/(1+np.exp(-x1))\n", 88 | " # Вычислить сигналы в нейронах выходного слоя. Взвешенная сумма.\n", 89 | " x2 = np.dot(self.weights_out, y1) # dot - умножение матриц X = W*I = weights * inputs\n", 90 | " \n", 91 | " return x2" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": 4, 97 | "metadata": { 98 | "collapsed": true 99 | }, 100 | "outputs": [], 101 | "source": [ 102 | " # ЗАДАЁМ ПАРАМЕТРЫ СЕТИ\n", 103 | "# Количество входных данных, слоев, нейронов\n", 104 | "data_input = 2\n", 105 | "data_neuron = 2\n", 106 | "data_output = 1\n", 107 | "\n", 108 | "# Cкорость обучения\n", 109 | "learningrate = 0.2\n", 110 | "\n", 111 | "# Создать экземпляр нейронной сети\n", 112 | "n = neuron_Net(data_input, data_neuron, data_output, learningrate)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 5, 118 | "metadata": { 119 | "collapsed": true 120 | }, 121 | "outputs": [], 122 | "source": [ 123 | " # ОБУЧЕНИЕ\n", 124 | "# Зададим количество эпох\n", 125 | "epochs = 70000\n", 126 | "# Прогон по обучающей выборке\n", 127 | "for e in range(epochs):\n", 128 | " for i in training_data_list:\n", 129 | " \n", 130 | " # Получить входные данные числа\n", 131 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 132 | " inputs_x = np.asfarray(all_values[1:])\n", 133 | " \n", 134 | " # Получить целевое значение Y, (ответ - какое это число)\n", 135 | " targets_Y = int(all_values[0]) # перевод символов в int, 0 элемент - ответ\n", 136 | " #targets_Y = np.asfarray(all_values[0],int) \n", 137 | " \n", 138 | " n.train(inputs_x, targets_Y) # наш метод train - обучение нейронной сети " 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 6, 144 | "metadata": {}, 145 | "outputs": [ 146 | { 147 | "name": "stdout", 148 | "output_type": "stream", 149 | "text": [ 150 | "Весовые коэффициенты:\n", 151 | " [[ 7.81432203 7.82825685]\n", 152 | " [ 2.89844863 2.90151462]]\n" 153 | ] 154 | } 155 | ], 156 | "source": [ 157 | "# Вывод обученных весов\n", 158 | "print('Весовые коэффициенты:\\n', n.weights)" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 7, 164 | "metadata": {}, 165 | "outputs": [ 166 | { 167 | "name": "stdout", 168 | "output_type": "stream", 169 | "text": [ 170 | "0 XOR 0 = 0.02727560400468576 \n", 171 | "\n", 172 | "1 XOR 0 = 0.993182895138375 \n", 173 | "\n", 174 | "0 XOR 1 = 0.9905392833501487 \n", 175 | "\n", 176 | "1 XOR 1 = 0.10921815839185456 \n", 177 | "\n" 178 | ] 179 | } 180 | ], 181 | "source": [ 182 | "# Прогоним входные данные из обучающей выборки через обученную сеть\n", 183 | "for i in training_data_list:\n", 184 | " all_values = i.split(',') # split(',') - разделить строку на символы где запятая \",\" символ разделения\n", 185 | " #all_values = np.asfarray(all_values,int) # Перевод списка в int \n", 186 | " inputs_x = np.asfarray(all_values[1:])\n", 187 | " # Прогон по сети\n", 188 | " outputs = n.query(inputs_x)\n", 189 | " print(int(all_values[1]), 'XOR', int(all_values[2]), '=' , float(outputs), '\\n') " 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": null, 195 | "metadata": { 196 | "collapsed": true 197 | }, 198 | "outputs": [], 199 | "source": [] 200 | } 201 | ], 202 | "metadata": { 203 | "kernelspec": { 204 | "display_name": "Python 3", 205 | "language": "python", 206 | "name": "python3" 207 | }, 208 | "language_info": { 209 | "codemirror_mode": { 210 | "name": "ipython", 211 | "version": 3 212 | }, 213 | "file_extension": ".py", 214 | "mimetype": "text/x-python", 215 | "name": "python", 216 | "nbconvert_exporter": "python", 217 | "pygments_lexer": "ipython3", 218 | "version": "3.6.3" 219 | } 220 | }, 221 | "nbformat": 4, 222 | "nbformat_minor": 2 223 | } 224 | -------------------------------------------------------------------------------- /neuralmaster/7_8/Neuron_no_or_2_4_1out.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import numpy as np" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 2, 17 | "metadata": { 18 | "collapsed": true 19 | }, 20 | "outputs": [], 21 | "source": [ 22 | "# Загрузить и подготовить тренировочные данные из формата CSV в список\n", 23 | "training_data = open(\"dataset/Data_train.csv\", 'r') # 'r' - открываем файл для чтения\n", 24 | "training_data_list = training_data.readlines() # readlines() - читает все строки в файле в переменную training_data_list\n", 25 | "training_data.close() # закрываем файл csv" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 3, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "# Определение класса нейронной сети\n", 37 | "class neuron_Net:\n", 38 | " \n", 39 | " # Инициализация параметров нейронной сети\n", 40 | " def __init__(self, input_num, neuron_num, output_num, learningrate):\n", 41 | " # МАТРИЦА ВЕСОВ\n", 42 | " # Задаем матрицу весов как случайное\n", 43 | " self.weights = (np.random.rand(neuron_num, input_num) +0.0)\n", 44 | " self.weights_out = (np.random.rand(output_num, neuron_num) +0.0)\n", 45 | " \n", 46 | " # Задаем параметр скорости обучения\n", 47 | " self.lr = learningrate\n", 48 | " \n", 49 | " pass\n", 50 | " \n", 51 | " # Метод обучения нейронной сети\n", 52 | " def train(self, inputs_list, targets_list): # принимает (вх. список данных, ответы)\n", 53 | " # Преобразовать список входов в вертикальный массив. .T - транспонирование\n", 54 | " inputs_x = np.array(inputs_list, ndmin=2).T # матрица числа\n", 55 | " targets_Y = np.array(targets_list, ndmin=2).T # матрица ответов\n", 56 | " \n", 57 | " # ВЫЧИСЛЕНИЕ СИГНАЛОВ\n", 58 | " # Вычислить сигналы в нейронах скрытого слоя. Взвешенная сумма.\n", 59 | " x1 = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 60 | " # Вычислить сигналы, выходящие из нейронов скрытого слоя. Функция активации - сигмоида(x)\n", 61 | " y1 = 1/(1+np.exp(-x1))\n", 62 | " # Вычислить сигналы в нейронах выходного слоя. Взвешенная сумма.\n", 63 | " x2 = np.dot(self.weights_out, y1) \n", 64 | " \n", 65 | " # ВЫЧИСЛЕНИЕ ОШИБКИ\n", 66 | " # Ошибка выходного слоя: E = -(цель - фактическое значение) \n", 67 | " E = -(targets_Y - x2)\n", 68 | " # Скрытая ошибка слоя\n", 69 | " E_hidden = np.dot(self.weights_out.T, E) \n", 70 | " \n", 71 | " # ОБНОВЛЕНИЕ ВЕСОВ\n", 72 | " # Меняем веса связей, исходящих из скрытого слоя\n", 73 | " self.weights_out -= self.lr * np.dot((E * x2), np.transpose(y1))\n", 74 | " # Меняем веса связей, исходящих из входного слоя\n", 75 | " self.weights -= self.lr * np.dot((E_hidden * y1 * (1.0 - y1)), np.transpose(inputs_x))\n", 76 | " \n", 77 | " pass\n", 78 | " \n", 79 | " # Метод прогона тестовых значений\n", 80 | " def query(self, inputs_list): # Принимает свой набор тестовых данных\n", 81 | " # Преобразовать список входов в вертикальный 2D массив. \n", 82 | " inputs_x = np.array(inputs_list, ndmin=2).T \n", 83 | " \n", 84 | " # Вычислить сигналы в нейронах скрытого слоя. Взвешенная сумма.\n", 85 | " x1 = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 86 | " # Вычислить сигналы, выходящие из нейронов скрытого слоя. Функция активации - сигмоида(x)\n", 87 | " y1 = 1/(1+np.exp(-x1))\n", 88 | " # Вычислить сигналы в нейронах выходного слоя. Взвешенная сумма.\n", 89 | " x2 = np.dot(self.weights_out, y1) \n", 90 | " \n", 91 | " return x2" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": 4, 97 | "metadata": { 98 | "collapsed": true 99 | }, 100 | "outputs": [], 101 | "source": [ 102 | " # ЗАДАЁМ ПАРАМЕТРЫ СЕТИ\n", 103 | "# Количество входных данных, слоев, нейронов\n", 104 | "data_input = 2\n", 105 | "data_neuron = 4\n", 106 | "data_output = 1\n", 107 | "\n", 108 | "# Cкорость обучения\n", 109 | "learningrate = 0.2\n", 110 | "\n", 111 | "# Создать экземпляр нейронной сети\n", 112 | "n = neuron_Net(data_input, data_neuron, data_output, learningrate)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 5, 118 | "metadata": { 119 | "collapsed": true 120 | }, 121 | "outputs": [], 122 | "source": [ 123 | " # ОБУЧЕНИЕ\n", 124 | "# Зададим количество эпох\n", 125 | "epochs = 70000\n", 126 | "# Прогон по обучающей выборке\n", 127 | "for e in range(epochs):\n", 128 | " for i in training_data_list:\n", 129 | " \n", 130 | " # Получить входные данные числа\n", 131 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 132 | " inputs_x = np.asfarray(all_values[1:])\n", 133 | " \n", 134 | " # Получить целевое значение Y, (ответ - какое это число)\n", 135 | " targets_Y = int(all_values[0]) # перевод символов в int, 0 элемент - ответ\n", 136 | " #targets_Y = np.asfarray(all_values[0],int) \n", 137 | " \n", 138 | " n.train(inputs_x, targets_Y) # наш метод train - обучение нейронной сети " 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 6, 144 | "metadata": {}, 145 | "outputs": [ 146 | { 147 | "name": "stdout", 148 | "output_type": "stream", 149 | "text": [ 150 | "Весовые коэффициенты:\n", 151 | " [[-2.33442417 -1.10601149]\n", 152 | " [ 3.85660315 4.00658125]\n", 153 | " [ 6.00766732 0.47282647]\n", 154 | " [ 0.38238545 6.08253924]]\n" 155 | ] 156 | } 157 | ], 158 | "source": [ 159 | "# Вывод обученных весов\n", 160 | "print('Весовые коэффициенты:\\n', n.weights)" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": 7, 166 | "metadata": {}, 167 | "outputs": [ 168 | { 169 | "name": "stdout", 170 | "output_type": "stream", 171 | "text": [ 172 | "0 XOR 0 = 0.0058097515306574365 \n", 173 | "\n", 174 | "1 XOR 0 = 0.9999538649241559 \n", 175 | "\n", 176 | "0 XOR 1 = 0.9999292912654436 \n", 177 | "\n", 178 | "1 XOR 1 = 0.008841038108958976 \n", 179 | "\n" 180 | ] 181 | } 182 | ], 183 | "source": [ 184 | "# Прогоним входные данные из обучающей выборки через обученную сеть\n", 185 | "for i in training_data_list:\n", 186 | " all_values = i.split(',') # split(',') - разделить строку на символы где запятая \",\" символ разделения\n", 187 | " #all_values = np.asfarray(all_values,int) # Перевод списка в int \n", 188 | " inputs_x = np.asfarray(all_values[1:])\n", 189 | " # Прогон по сети\n", 190 | " outputs = n.query(inputs_x)\n", 191 | " print(int(all_values[1]), 'XOR', int(all_values[2]), '=' , float(outputs), '\\n') " 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": null, 197 | "metadata": { 198 | "collapsed": true 199 | }, 200 | "outputs": [], 201 | "source": [] 202 | } 203 | ], 204 | "metadata": { 205 | "kernelspec": { 206 | "display_name": "Python 3", 207 | "language": "python", 208 | "name": "python3" 209 | }, 210 | "language_info": { 211 | "codemirror_mode": { 212 | "name": "ipython", 213 | "version": 3 214 | }, 215 | "file_extension": ".py", 216 | "mimetype": "text/x-python", 217 | "name": "python", 218 | "nbconvert_exporter": "python", 219 | "pygments_lexer": "ipython3", 220 | "version": "3.6.3" 221 | } 222 | }, 223 | "nbformat": 4, 224 | "nbformat_minor": 2 225 | } 226 | -------------------------------------------------------------------------------- /neuralmaster/7_8/Neuron_no_or_2out.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import numpy as np" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 2, 17 | "metadata": { 18 | "collapsed": true 19 | }, 20 | "outputs": [], 21 | "source": [ 22 | "# Загрузить и подготовить тренировочные данные из формата CSV в список\n", 23 | "training_data = open(\"dataset/Data_train.csv\", 'r') # 'r' - открываем файл для чтения\n", 24 | "training_data_list = training_data.readlines() # readlines() - читает все строки в файле в переменную training_data_list\n", 25 | "training_data.close() # закрываем файл csv" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 3, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "# Определение класса нейронной сети\n", 37 | "class neuron_Net:\n", 38 | " \n", 39 | " # Инициализация весов нейронной сети\n", 40 | " def __init__(self, input_num, neuron_num, output_num, learningrate):\n", 41 | " # МАТРИЦА ВЕСОВ\n", 42 | " # Задаем матрицу весов как случайное\n", 43 | " self.weights = (np.random.rand(neuron_num, input_num) +0.0)\n", 44 | " self.weights_out = (np.random.rand(output_num, neuron_num) +0.0)\n", 45 | " \n", 46 | " # Задаем параметр скорости обучения\n", 47 | " self.lr = learningrate\n", 48 | " \n", 49 | " pass\n", 50 | " \n", 51 | " # Метод обучения нейронной сети\n", 52 | " def train(self, inputs_list, targets_list): # принимает (вх. список данных, ответы)\n", 53 | " # Преобразовать список входов в вертикальный массив. .T - транспонирование\n", 54 | " inputs_x = np.array(inputs_list, ndmin=2).T # матрица числа\n", 55 | " targets_Y = np.array(targets_list, ndmin=2).T # матрица ответов: какое это число\n", 56 | " \n", 57 | " # ВЫЧИСЛЕНИЕ СИГНАЛОВ\n", 58 | " # Вычислить сигналы в нейронах скрытого слоя. Взвешенная сумма.\n", 59 | " x1 = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 60 | " # Вычислить сигналы, выходящие из нейрона. Функция активации - сигмоида(x)\n", 61 | " y1 = 1/(1+np.exp(-x1))\n", 62 | " # Вычислить сигналы в нейронах выходного слоя. Взвешенная сумма.\n", 63 | " x2 = np.dot(self.weights_out, y1) # dot - умножение матриц X = W*I = weights * inputs\n", 64 | " # Вычислить сигналы, выходящие из нейрона. Функция активации - сигмоида(x)\n", 65 | " y2 = 1/(1+np.exp(-x2))\n", 66 | " \n", 67 | " # ВЫЧИСЛЕНИЕ ОШИБКИ\n", 68 | " # Ошибка E = -(цель - фактическое значение) \n", 69 | " E = -(targets_Y - y2)\n", 70 | " # Ошибка скрытого слоя\n", 71 | " E_hidden = np.dot(self.weights_out.T, E) \n", 72 | " \n", 73 | " # ОБНОВЛЕНИЕ ВЕСОВ\n", 74 | " # Меняем веса по каждой связи\n", 75 | " self.weights_out -= self.lr * np.dot((E * y2 * (1.0 - y2)), np.transpose(y1))\n", 76 | " # Меняем веса по каждой связи\n", 77 | " self.weights -= self.lr * np.dot((E_hidden * y1 * (1.0 - y1)), np.transpose(inputs_x))\n", 78 | " \n", 79 | " pass\n", 80 | " \n", 81 | " # Метод прогона тестовых значений\n", 82 | " def query(self, inputs_list): # Принимает свой набор тестовых данных\n", 83 | " # Преобразовать список входов в вертикальный массив. \n", 84 | " inputs_x = np.array(inputs_list, ndmin=2).T \n", 85 | " \n", 86 | " # Вычислить сигналы в нейронах скрытого слоя. Взвешенная сумма.\n", 87 | " x1 = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 88 | " # Вычислить сигналы, выходящие из нейрона. Функция активации - сигмоида(x)\n", 89 | " y1 = 1/(1+np.exp(-x1))\n", 90 | " # Вычислить сигналы в нейронах выходного слоя. Взвешенная сумма.\n", 91 | " x2 = np.dot(self.weights_out, y1) # dot - умножение матриц X = W*I = weights * inputs\n", 92 | " # Вычислить сигналы, выходящие из нейрона. Функция активации - сигмоида(x)\n", 93 | " y2 = 1/(1+np.exp(-x2))\n", 94 | " \n", 95 | " return y2" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 4, 101 | "metadata": { 102 | "collapsed": true 103 | }, 104 | "outputs": [], 105 | "source": [ 106 | " # ЗАДАЁМ ПАРАМЕТРЫ СЕТИ\n", 107 | "# Количество входных данных, нейронов\n", 108 | "data_input = 2\n", 109 | "data_neuron = 4\n", 110 | "data_output = 2\n", 111 | "\n", 112 | "# Cкорость обучения\n", 113 | "learningrate = 0.2\n", 114 | "\n", 115 | "# Создать экземпляр нейронной сети\n", 116 | "n = neuron_Net(data_input, data_neuron, data_output, learningrate)" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 5, 122 | "metadata": { 123 | "collapsed": true 124 | }, 125 | "outputs": [], 126 | "source": [ 127 | " # ОБУЧЕНИЕ\n", 128 | "# Зададим количество эпох\n", 129 | "epochs = 80000\n", 130 | "# Прогон по обучающей выборке\n", 131 | "for e in range(epochs):\n", 132 | " for i in training_data_list:\n", 133 | " # Получить входные данные числа\n", 134 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 135 | " inputs_x = np.asfarray(all_values[1:])\n", 136 | " \n", 137 | " # Получить целевое значение Y, (ответ - какое это число)\n", 138 | " targets_Y = int(all_values[0]) # перевод символов в int, 0 элемент - ответ\n", 139 | " \n", 140 | " # создать целевые выходные значения (все 0.01, кроме нужной метки, которая равна 0.99)\n", 141 | " targets_Y = np.zeros(data_output) + 0.01\n", 142 | " \n", 143 | " # Получить целевое значение Y, (ответ - какое это число). all_values[0] - целевая метка для этой записи\n", 144 | " targets_Y[int(all_values[0])] = 0.99\n", 145 | " \n", 146 | " n.train(inputs_x, targets_Y) # наш метод train - обучение нейронной сети " 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": 6, 152 | "metadata": {}, 153 | "outputs": [ 154 | { 155 | "name": "stdout", 156 | "output_type": "stream", 157 | "text": [ 158 | "Весовые коэффициенты:\n", 159 | " [[ 12.95040394 -6.49232526]\n", 160 | " [ -9.08125352 -8.94676728]\n", 161 | " [-13.09373108 6.56168093]\n", 162 | " [ 7.32763501 -14.51411564]]\n" 163 | ] 164 | } 165 | ], 166 | "source": [ 167 | "# Вывод обученных весов\n", 168 | "print('Весовые коэффициенты:\\n', n.weights)" 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": 7, 174 | "metadata": {}, 175 | "outputs": [ 176 | { 177 | "name": "stdout", 178 | "output_type": "stream", 179 | "text": [ 180 | "0 XOR 0 = 0 \n", 181 | " [[ 0.97987662]\n", 182 | " [ 0.02012364]]\n", 183 | "1 XOR 0 = 1 \n", 184 | " [[ 0.0181055 ]\n", 185 | " [ 0.98189458]]\n", 186 | "0 XOR 1 = 1 \n", 187 | " [[ 0.01725169]\n", 188 | " [ 0.98274808]]\n", 189 | "1 XOR 1 = 0 \n", 190 | " [[ 0.985501 ]\n", 191 | " [ 0.0144984]]\n" 192 | ] 193 | } 194 | ], 195 | "source": [ 196 | "# Прогоним входные данные из обучающей выборки через обученную сеть\n", 197 | "for i in training_data_list:\n", 198 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 199 | " #all_values = np.asfarray(all_values,int) # Перевод списка в int \n", 200 | " inputs_x = np.asfarray(all_values[1:])\n", 201 | " # Прогон по сети\n", 202 | " outputs = n.query(inputs_x)\n", 203 | " print(int(all_values[1]), 'XOR', int(all_values[2]), '=' , np.argmax(outputs), '\\n',outputs) " 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": null, 209 | "metadata": { 210 | "collapsed": true 211 | }, 212 | "outputs": [], 213 | "source": [] 214 | } 215 | ], 216 | "metadata": { 217 | "kernelspec": { 218 | "display_name": "Python 3", 219 | "language": "python", 220 | "name": "python3" 221 | }, 222 | "language_info": { 223 | "codemirror_mode": { 224 | "name": "ipython", 225 | "version": 3 226 | }, 227 | "file_extension": ".py", 228 | "mimetype": "text/x-python", 229 | "name": "python", 230 | "nbconvert_exporter": "python", 231 | "pygments_lexer": "ipython3", 232 | "version": "3.6.3" 233 | } 234 | }, 235 | "nbformat": 4, 236 | "nbformat_minor": 2 237 | } 238 | -------------------------------------------------------------------------------- /neuralmaster/7_8/Neuron_or_1out.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "collapsed": true 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import numpy as np" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 2, 17 | "metadata": { 18 | "collapsed": true 19 | }, 20 | "outputs": [], 21 | "source": [ 22 | "# Загрузить и подготовить тренировочные данные из формата CSV в список\n", 23 | "training_data = open(\"dataset/Data_or.csv\", 'r') # 'r' - открываем файл для чтения\n", 24 | "training_data_list = training_data.readlines() # readlines() - читает все строки в файле в переменную training_data_list\n", 25 | "training_data.close() # закрываем файл csv" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 3, 31 | "metadata": { 32 | "collapsed": true 33 | }, 34 | "outputs": [], 35 | "source": [ 36 | "# Определение класса нейронной сети\n", 37 | "class neuron_Net:\n", 38 | " \n", 39 | " # Инициализация весов нейронной сети\n", 40 | " def __init__(self, input_num, neuron_num, output_num, learningrate): #констр.(кол-во входов, кол-во нейронов)\n", 41 | " # МАТРИЦА ВЕСОВ\n", 42 | " # Задаем матрицу весов как случайное от -0,5 до 0,5\n", 43 | " self.weights = (np.random.rand(neuron_num, input_num) +0.0)\n", 44 | " self.weights_out = (np.random.rand(output_num, neuron_num) +0.0)\n", 45 | " \n", 46 | " # Задаем параметр скорости обучения\n", 47 | " self.lr = learningrate\n", 48 | " \n", 49 | " pass\n", 50 | " \n", 51 | " # Метод обучения нейронной сети\n", 52 | " def train(self, inputs_list, targets_list): # принимает (вх. список данных, ответы)\n", 53 | " # Преобразовать список входов в вертикальный массив. .T - транспонирование\n", 54 | " inputs_x = np.array(inputs_list, ndmin=2).T # матрица числа\n", 55 | " targets_Y = np.array(targets_list, ndmin=2).T # матрица ответов: какое это число\n", 56 | " \n", 57 | " # ВЫЧИСЛЕНИЕ СИГНАЛОВ\n", 58 | " # Вычислить сигналы в нейронах скрытого слоя. Взвешенная сумма.\n", 59 | " x1 = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 60 | " # Вычислить сигналы, выходящие из нейронов скрытого слоя. Функция активации - сигмоида(x)\n", 61 | " y1 = 1/(1+np.exp(-x1))\n", 62 | " # Вычислить сигналы в нейронах выходного слоя. Взвешенная сумма.\n", 63 | " x2 = np.dot(self.weights_out, y1) \n", 64 | " \n", 65 | " # ВЫЧИСЛЕНИЕ ОШИБКИ\n", 66 | " # Ошибка E = -(цель - фактическое значение) \n", 67 | " E = -(targets_Y - x2)\n", 68 | " # Ошибка скрытого слоя\n", 69 | " E_hidden = np.dot(self.weights_out.T, E) \n", 70 | " \n", 71 | " # ОБНОВЛЕНИЕ ВЕСОВ\n", 72 | " # Меняем веса исходящих из скрытого слоя\n", 73 | " self.weights_out -= self.lr * np.dot((E * x2), np.transpose(y1))\n", 74 | " # Меняем веса исходящих из входного слоя\n", 75 | " self.weights -= self.lr * np.dot((E_hidden * y1 * (1.0 - y1)), np.transpose(inputs_x))\n", 76 | " \n", 77 | " pass\n", 78 | " \n", 79 | " # Метод прогона тестовых значений\n", 80 | " def query(self, inputs_list): # Принимает свой набор тестовых данных\n", 81 | " # Преобразовать список входов в вертикальный 2D массив. \n", 82 | " inputs_x = np.array(inputs_list, ndmin=2).T \n", 83 | " \n", 84 | " # Вычислить сигналы в нейронах скрытого слоя. Взвешенная сумма.\n", 85 | " x1 = np.dot(self.weights, inputs_x) # dot - умножение матриц X = W*I = weights * inputs\n", 86 | " # Вычислить сигналы, выходящие из нейронов скрытого слоя. Функция активации - сигмоида(x)\n", 87 | " y1 = 1/(1+np.exp(-x1))\n", 88 | " # Вычислить сигналы в нейронах выходного слоя. Взвешенная сумма.\n", 89 | " x2 = np.dot(self.weights_out, y1) \n", 90 | " \n", 91 | " return x2" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": 4, 97 | "metadata": { 98 | "collapsed": true 99 | }, 100 | "outputs": [], 101 | "source": [ 102 | " # ЗАДАЁМ ПАРАМЕТРЫ СЕТИ\n", 103 | "# Количество входных данных, нейронов\n", 104 | "data_input = 2\n", 105 | "data_neuron = 2\n", 106 | "data_output = 1\n", 107 | "\n", 108 | "# Cкорость обучения\n", 109 | "learningrate = 0.2\n", 110 | "\n", 111 | "# Создать экземпляр нейронной сети\n", 112 | "n = neuron_Net(data_input, data_neuron, data_output, learningrate)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 5, 118 | "metadata": { 119 | "collapsed": true 120 | }, 121 | "outputs": [], 122 | "source": [ 123 | " # ОБУЧЕНИЕ\n", 124 | "# Зададим количество эпох\n", 125 | "epochs = 70000\n", 126 | "# Прогон по обучающей выборке\n", 127 | "for e in range(epochs):\n", 128 | " for i in training_data_list:\n", 129 | " # Получить входные данные числа\n", 130 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения\n", 131 | " inputs_x = np.asfarray(all_values[1:])\n", 132 | " \n", 133 | " # Получить целевое значение Y, (ответ - какое это число)\n", 134 | " targets_Y = int(all_values[0]) # перевод символов в int, 0 элемент - ответ\n", 135 | " \n", 136 | " # Получить целевое значение Y, (ответ - какое это число). all_values[0] - целевая метка для этой записи\n", 137 | " targets_Y = np.asfarray(all_values[0],int)\n", 138 | " \n", 139 | " n.train(inputs_x, targets_Y) # наш метод train - обучение нейронной сети " 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 6, 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | "Весовые коэффициенты:\n", 152 | " [[ 2.95719849 3.05322881]\n", 153 | " [ 0.1741739 0.19161757]]\n" 154 | ] 155 | } 156 | ], 157 | "source": [ 158 | "# Вывод обученных весов\n", 159 | "print('Весовые коэффициенты:\\n', n.weights)" 160 | ] 161 | }, 162 | { 163 | "cell_type": "code", 164 | "execution_count": 7, 165 | "metadata": {}, 166 | "outputs": [ 167 | { 168 | "name": "stdout", 169 | "output_type": "stream", 170 | "text": [ 171 | "0 OR 0 = 0.0015221568573919875 \n", 172 | "\n", 173 | "1 OR 0 = 0.9999989042032791 \n", 174 | "\n", 175 | "0 OR 1 = 0.9999985457530554 \n", 176 | "\n", 177 | "1 OR 1 = 1.000000835153846 \n", 178 | "\n" 179 | ] 180 | } 181 | ], 182 | "source": [ 183 | "# Прогоним входные данные из обучающей выборки через обученную сеть\n", 184 | "for i in training_data_list:\n", 185 | " all_values = i.split(',') # split(',') - раздел строку на символы где запятая \",\" символ разделения \n", 186 | " inputs_x = np.asfarray(all_values[1:])\n", 187 | " # Прогон по сети\n", 188 | " outputs = n.query(inputs_x)\n", 189 | " print(int(all_values[1]), 'OR', int(all_values[2]), '=' , float(outputs), '\\n') " 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": null, 195 | "metadata": { 196 | "collapsed": true 197 | }, 198 | "outputs": [], 199 | "source": [] 200 | } 201 | ], 202 | "metadata": { 203 | "kernelspec": { 204 | "display_name": "Python 3", 205 | "language": "python", 206 | "name": "python3" 207 | }, 208 | "language_info": { 209 | "codemirror_mode": { 210 | "name": "ipython", 211 | "version": 3 212 | }, 213 | "file_extension": ".py", 214 | "mimetype": "text/x-python", 215 | "name": "python", 216 | "nbconvert_exporter": "python", 217 | "pygments_lexer": "ipython3", 218 | "version": "3.6.3" 219 | } 220 | }, 221 | "nbformat": 4, 222 | "nbformat_minor": 2 223 | } 224 | -------------------------------------------------------------------------------- /neuralmaster/7_8/dataset/Data_or.csv: -------------------------------------------------------------------------------- 1 | 0,0,0 2 | 1,1,0 3 | 1,0,1 4 | 1,1,1 5 | -------------------------------------------------------------------------------- /neuralmaster/7_8/dataset/Data_sin.csv: -------------------------------------------------------------------------------- 1 | 0.5,0.01 2 | 0.6477601,0.03 3 | 0.78232124,0.06 4 | 0.89166345,0.09 5 | 0.96601954,0.12 6 | 0.99,0.15 7 | 0.98692382,0.18 8 | 0.93160468,0.21 9 | 0.83773159,0.24 10 | 0.71368994,0.27 11 | 0.57056,0.3 12 | 0.42112715,0.33 13 | 0.27873978,0.36 14 | 0.15611692,0.39 15 | 0.06421211,0.42 16 | 0.01123494,0.45 17 | 0.0019177,0.48 18 | 0.03709266,0.51 19 | 0.11361776,0.54 20 | 0.22465723,0.57 21 | 0.36029225,0.6 22 | 0.50840695,0.63 23 | 0.65577068,0.66 24 | 0.78921988,0.69 25 | 0.89683393,0.72 26 | 0.96899999,0.75 27 | 0.99,0.78 28 | 0.98494491,0.81 29 | 0.92729945,0.84 30 | 0.83148462,0.87 31 | 0.70605924,0.9 32 | 0.56222721,0.93 33 | 0.41283661,0.96 34 | 0.27123205,0.99 35 | -------------------------------------------------------------------------------- /neuralmaster/7_8/dataset/Data_sin_1.csv: -------------------------------------------------------------------------------- 1 | 0.5,0.01 2 | 0.64,0.03 3 | 0.78,0.06 4 | 0.89,0.09 5 | 0.96,0.12 6 | 0.99,0.15 7 | 0.98,0.18 8 | 0.93,0.21 9 | 0.83,0.24 10 | 0.71,0.27 11 | 0.57,0.3 12 | 0.42,0.33 13 | 0.27,0.36 14 | 0.15,0.39 15 | 0.06,0.42 16 | 0.01,0.45 17 | 0.01,0.48 18 | 0.04,0.51 19 | 0.11,0.54 20 | 0.22,0.57 21 | 0.36,0.6 22 | 0.50,0.63 23 | 0.65,0.66 24 | 0.78,0.69 25 | 0.89,0.72 26 | 0.96,0.75 27 | 0.99,0.78 28 | 0.98,0.81 29 | 0.92,0.84 30 | 0.83,0.87 31 | 0.70,0.9 32 | 0.56,0.93 33 | 0.41,0.96 34 | 0.27,0.99 35 | -------------------------------------------------------------------------------- /neuralmaster/7_8/dataset/Data_sin_x.csv: -------------------------------------------------------------------------------- 1 | [0, 0.025, 0.05, 0.07500000000000001, 0.1, 0.125, 0.15, 0.175, 0.19999999999999998, 0.22499999999999998, 0.24999999999999997, 0.27499999999999997, 0.3, 0.325, 0.35000000000000003, 0.37500000000000006, 0.4000000000000001, 0.4250000000000001, 0.4500000000000001, 0.47500000000000014, 0.5000000000000001, 0.5250000000000001, 0.5500000000000002, 0.5750000000000002, 0.6000000000000002, 0.6250000000000002, 0.6500000000000002, 0.6750000000000003, 0.7000000000000003, 0.7250000000000003, 0.7500000000000003, 0.7750000000000004, 0.8000000000000004, 0.8250000000000004, 0.8500000000000004, 0.8750000000000004, 0.9000000000000005, 0.9250000000000005, 0.9500000000000005, 0.9750000000000005] -------------------------------------------------------------------------------- /neuralmaster/7_8/dataset/Data_sin_y.csv: -------------------------------------------------------------------------------- 1 | [0.48, 0.598753900442171, 0.7101242585300174, 0.8071866048112004, 0.8839060727077903, 0.9355126172906814, 0.9587975935699461, 0.9523132544994897, 0.9164627648763273, 0.8534751345062022, 0.7672666291698993, 0.6631972761851194, 0.5477376038687363, 0.42806633542554795, 0.31162405070898225, 0.2056505670036748, 0.11673480225219418, 0.0504051080502797, 0.010785543520753338, 0.0003394612918186102, 0.019716348161693653, 0.06771144315523625, 0.14134064372621247, 0.23602604280035672, 0.34588056086451635, 0.46407397605717354, 0.5832575942821527, 0.6960211554146976, 0.7953535673850196, 0.8750788219255236, 0.9302399888518752, 0.9574074139733646, 0.954891958379223, 0.9228500209148827, 0.8632738140592743, 0.779867497802011, 0.6778168729160408, 0.5634669529826055, 0.44392746217832896, 0.3266307870613062] -------------------------------------------------------------------------------- /neuralmaster/7_8/dataset/Data_test.csv: -------------------------------------------------------------------------------- 1 | 0,0,0 2 | 1,1,0 3 | 1,0,1 4 | 0,1,1 5 | -------------------------------------------------------------------------------- /neuralmaster/7_8/dataset/Data_train.csv: -------------------------------------------------------------------------------- 1 | 0,0,0 2 | 1,1,0 3 | 1,0,1 4 | 0,1,1 5 | --------------------------------------------------------------------------------