Написать и обучить модели нейронных сетей
давайте сделаем один Мы предполагаем, что в алгоритме нейронной сети есть только один узел и есть только один выход.
наборы инструментов, связанные с импортом
import numpy as np
import tensorflow as tf
from tensorflow import keras
Данные тренировки следующие:
x_train = np.array([1.0, 2.0, 3.0, 4.0, 5.0], dtype=float)
y_tarin = np.array([3.0, 5.0, 7.0, 9.0, 11.0], dtype=float)
На самом деле легко обнаружить, что это намеренно сконструированный набор данных, и между входными и выходными данными существует линейная зависимость.
Давайте ознакомимся с основным методом записи tensorflow на простейшем случае.
Определение модели нейронной сети
model = tf.keras.Sequential([keras.layers.Dense(units=1, input_shape = [1])])
Определим структуру нейронной сети последовательно: Последовательность означает последовательность. Он представляет собой последовательность слоев, которая является сетевым уровнем. Последовательный аргумент представляет собой массив. Каждый элемент массива представляет собой слой.
Есть и другой способ записи:
model = tf.keras.Sequential()
model.add(kears.layers.Dense(unit-1, input_shape = [1])
Здесь сначала определяется объект Sequential, но конкретный слой не добавляется. Вместо этого он добавляется с помощью метода add.
Скомпилируйте нейронную сеть
Мы определили модель нейронной сети на предыдущем шаге. При обучении модели есть два ключевых момента: 1. После обработки данных моделью, как судить о точности результатов? Здесь нам нужна функция потерь для измерения этого результата. Это потеря. 2. Если результаты неточны, как модель корректирует свои параметры? Здесь нужен оптимизатор. То есть оптимизатор.
В коде это отражено следующим образом:
model.compile(optimizer='sgd', loss='mean_squared_error')
Здесь оптимизатор использует sgd, стохастический градиентный спуск. Функция потерь использует mean_squared_error, который представляет собой среднеквадратичную ошибку.
Каковы конкретные функции потерь и оптимизаторы, о которых можно будет подробно рассказать позже.
обучать нейронную сеть
model.fit(x_train, y_train, epochs=1000)
Результат выглядит следующим образом:
Epoch 1/1000
1/1 [==============================] - 0s 133ms/step - loss: 34.4833
Epoch 2/1000
1/1 [==============================] - 0s 998us/step - loss: 27.4619
Epoch 3/1000
1/1 [==============================] - 0s 998us/step - loss: 21.9311
Epoch 4/1000
1/1 [==============================] - 0s 2ms/step - loss: 17.5730
Epoch 5/1000
1/1 [==============================] - 0s 2ms/step - loss: 14.1377
Epoch 6/1000
1/1 [==============================] - 0s 2ms/step - loss: 11.4285
Epoch 7/1000
1/1 [==============================] - 0s 2ms/step - loss: 9.2908
Epoch 8/1000
1/1 [==============================] - 0s 998us/step - loss: 7.6029
Epoch 9/1000
1/1 [==============================] - 0s 2ms/step - loss: 6.2688
Epoch 10/1000
1/1 [==============================] - 0s 2ms/step - loss: 5.2133
Epoch 11/1000
1/1 [==============================] - 0s 2ms/step - loss: 4.3772
.
.
.
Epoch 997/1000
1/1 [==============================] - 0s 997us/step - loss: 1.8421e-09
Epoch 998/1000
1/1 [==============================] - 0s 2ms/step - loss: 1.8046e-09
Epoch 999/1000
1/1 [==============================] - 0s 3ms/step - loss: 1.7623e-09
Epoch 1000/1000
1/1 [==============================] - 0s 2ms/step - loss: 1.7328e-09
Наконец я увидел, что потери были очень малы. Похоже, тренировочный лагерь закончился.
Итак, давайте предскажем несколько результатов.
тестовый набор
x_test = np.array([5.0, 3.0, 2.0, 4.0, 0.0], dtype=float)
print(model.predict(x_test))
Результат выглядит следующим образом:
[[11.000036 ]
[ 6.9999986]
[ 4.99998 ]
[ 9.000017 ]
[ 0.9999426]]
Фактически, это согласуется с нашими предопределенными законами данных, в основном в соответствии с y = 2 * x + 1.
сомневаться
Почему в окончательных результатах предсказанные результаты представляют собой не целые числа, а числа с плавающей запятой, которые очень близки к целым числам.
Это связано с тем, что при обучении модели, хотя мы и обучились на 1000 раундов, у нас еще не самые идеальные параметры, но алгоритм градиентного спуска уже нашел очень хорошее решение.
С другой стороны, не обязательно полностью соблюдать закон y = 2 * x + 1, потому что может возникнуть переобучение.