Как тренировать модель линейной регрессии в Tensorflow
11 июня 2025 г.Обзор контента
- Настраивать
- Решение проблем машинного обучения
- Данные
- Определите модель
- Определить функцию потери
- Определите петлю обучения
- То же решение, но с керами
- Следующие шаги
В предыдущих гидах вы узнали отензорыВпеременныеВградиентная лента, имодулиПолем В этом руководстве вы будете соединить все это вместе для обучения моделей.
TensorFlow также включаетtf.keras api, высокоуровневый API нейронной сети, который обеспечивает полезные абстракции для уменьшения шаблона. Однако в этом руководстве вы будете использовать базовые классы.
Настраивать
import tensorflow as tf
import matplotlib.pyplot as plt
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
Решение проблем машинного обучения
Решение проблемы машинного обучения обычно состоит из следующих шагов:
- Получить данные обучения.
- Определите модель.
- Определите функцию потери.
- Запустите учебные данные, вычисляя потерю из идеального значения
- Рассчитайте градиенты для этой потери и используйтеоптимизаторЧтобы настроить переменные в соответствии с данными.
- Оцените свои результаты.
В целях иллюстрации в этом руководстве вы разработаете простую линейную модель, f (x) = x ∗ w+b, которая имеет две переменные: w (вес (вес) и B (смещение).
Это самые основные задачи машинного обучения: с учетом x и y, попробуйте найти наклон и смещение линии черезПростая линейная регрессияПолем
Данные
Контролируемое обучение используетсявходные данные(обычно обозначается какх) ивыходы(обозначеноу, часто называетсяярлыки) Цель состоит в том, чтобы учиться на парных входах и выходах, чтобы вы могли предсказать значение вывода с ввода.
Каждый ввод ваших данных, в Tensorflow, почти всегда представлен тензором и часто является вектором. При поддержании обучения вывод (или значение, которое вы хотели бы предсказать) также является тензором.
Вот некоторые данные, синтезированные путем добавления гауссовского (нормального) шума в точки вдоль линии.
# The actual line
TRUE_W = 3.0
TRUE_B = 2.0
NUM_EXAMPLES = 201
# A vector of random x values
x = tf.linspace(-2,2, NUM_EXAMPLES)
x = tf.cast(x, tf.float32)
def f(x):
return x * TRUE_W + TRUE_B
# Generate some noise
noise = tf.random.normal(shape=[NUM_EXAMPLES])
# Calculate y
y = f(x) + noise
# Plot all the data
plt.plot(x, y, '.')
plt.show()
Тензоры обычно собираются вместе впартии, или группы входов и выходов, сложенных вместе. Партия может предоставить некоторые учебные выгоды и хорошо работает с ускорителями и векторизованными вычислениями. Учитывая, насколько мал этот набор данных, вы можете рассматривать весь набор данных как одну партию.
Определите модель
Использоватьtf.Variableпредставлять все веса в модели. Аtf.Variableхранит значение и предоставляет это в форме тензора по мере необходимости. УвидетьРуководство с переменнойДля получения более подробной информации.
Использоватьtf.Moduleинкапсулировать переменные и вычисления. Вы можете использовать любой объект Python, но таким образом его можно легко сохранить.
Здесь вы определяете обаW.ибеременныйкак переменные.
class MyModel(tf.Module):
def __init__(self, **kwargs):
super().__init__(**kwargs)
# Initialize the weights to `5.0` and the bias to `0.0`
# In practice, these should be randomly initialized
self.w = tf.Variable(5.0)
self.b = tf.Variable(0.0)
def __call__(self, x):
return self.w * x + self.b
model = MyModel()
# List the variables tf.modules's built-in variable aggregation.
print("Variables:", model.variables)
# Verify the model works
assert model(3.0).numpy() == 15.0
Исходные переменные установлены здесь в фиксированнойинициализаторыВы можете использовать, с остальной частью кера или без него.
Определить функцию потери
Функция потери измеряет, насколько хорошо вывод модели для данного входа соответствует целевому выводу. Цель состоит в том, чтобы минимизировать эту разницу во время обучения. Определите стандартную потерю L2, также известную как ошибка «среднее квадрат»:
# This computes a single loss value for an entire batch
def loss(target_y, predicted_y):
return tf.reduce_mean(tf.square(target_y - predicted_y))
Перед обучением модели вы можете визуализировать значение потери, построив прогнозы модели в красном и учебные данные в синем виде:
plt.plot(x, y, '.', label="Data")
plt.plot(x, f(x), label="Ground truth")
plt.plot(x, model(x), label="Predictions")
plt.legend()
plt.show()
print("Current loss: %1.6f" % loss(y, model(x)).numpy())
Определите петлю обучения
Обучающая петля состоит из неоднократно выполнения трех задач по порядку:
- Отправка партии входов через модель для генерации выходов
- Расчет потерь путем сравнения выходов с выходом (или меткой)
- Использование градиентной ленты, чтобы найти градиенты
- Оптимизация переменных с этими градиентами
Для этого примера вы можете обучить модель, используяградиент спускПолем
Есть много вариантов схемы градиентного происхождения, которые фиксируются вtf.keras.optimizersПолем Но в духе строительства из первых принципов вы сами реализуете основную математику с помощьюtf.GradientTapeдля автоматической дифференциации иtf.assign_subдля снижения значения (которое объединяетtf.assignиtf.sub):
# Given a callable model, inputs, outputs, and a learning rate...
def train(model, x, y, learning_rate):
with tf.GradientTape() as t:
# Trainable variables are automatically tracked by GradientTape
current_loss = loss(y, model(x))
# Use GradientTape to calculate the gradients with respect to W and b
dw, db = t.gradient(current_loss, [model.w, model.b])
# Subtract the gradient scaled by the learning rate
model.w.assign_sub(learning_rate * dw)
model.b.assign_sub(learning_rate * db)
Чтобы посмотреть на обучение, вы можете отправить ту же партиюхиучерез петлю обучения и посмотрите, какWиbэволюционировать.
model = MyModel()
# Collect the history of W-values and b-values to plot later
weights = []
biases = []
epochs = range(10)
# Define a training loop
def report(model, loss):
return f"W = {model.w.numpy():1.2f}, b = {model.b.numpy():1.2f}, loss={loss:2.5f}"
def training_loop(model, x, y):
for epoch in epochs:
# Update the model with the single giant batch
train(model, x, y, learning_rate=0.1)
# Track this before I update
weights.append(model.w.numpy())
biases.append(model.b.numpy())
current_loss = loss(y, model(x))
print(f"Epoch {epoch:2d}:")
print(" ", report(model, current_loss))
Сделайте обучение
current_loss = loss(y, model(x))
print(f"Starting:")
print(" ", report(model, current_loss))
training_loop(model, x, y)
Построить эволюцию весов со временем:
plt.plot(epochs, weights, label='Weights', color=colors[0])
plt.plot(epochs, [TRUE_W] * len(epochs), '--',
label = "True weight", color=colors[0])
plt.plot(epochs, biases, label='bias', color=colors[1])
plt.plot(epochs, [TRUE_B] * len(epochs), "--",
label="True bias", color=colors[1])
plt.legend()
plt.show()
Визуализировать, как работает обученная модель
plt.plot(x, y, '.', label="Data")
plt.plot(x, f(x), label="Ground truth")
plt.plot(x, model(x), label="Predictions")
plt.legend()
plt.show()
print("Current loss: %1.6f" % loss(model(x), y).numpy())
То же решение, но с керами
Полезно сопоставить приведенный выше код с эквивалентом в керах.
Определение модели выглядит точно так же, если вы подклассtf.keras.ModelПолем Помните, что модели Keras наследуют в конечном итоге от модуля.
class MyModelKeras(tf.keras.Model):
def __init__(self, **kwargs):
super().__init__(**kwargs)
# Initialize the weights to `5.0` and the bias to `0.0`
# In practice, these should be randomly initialized
self.w = tf.Variable(5.0)
self.b = tf.Variable(0.0)
def call(self, x):
return self.w * x + self.b
keras_model = MyModelKeras()
# Reuse the training loop with a Keras model
training_loop(keras_model, x, y)
# You can also save a checkpoint using Keras's built-in support
keras_model.save_weights("my_checkpoint")
Вместо того, чтобы писать новые тренировочные циклы каждый раз, когда вы создаете модель, вы можете использовать встроенные функции Keras в качестве ярлыка. Это может быть полезно, когда вы не хотите писать или отлаживать петли обучения Python.
Если вы это сделаете, вам нужно будет использоватьmodel.compile()Чтобы установить параметры, иmodel.fit()тренировать. Это может быть меньше кода для использования реализаций кераса потерь L2 и градиентного спуска, опять же в качестве ярлыка. Потери и оптимизаторы кераса также могут использоваться вне этих удобных функций, и предыдущий пример мог бы их использовать.
keras_model = MyModelKeras()
# compile sets the training parameters
keras_model.compile(
# By default, fit() uses tf.function(). You can
# turn that off for debugging, but it is on now.
run_eagerly=False,
# Using a built-in optimizer, configuring as an object
optimizer=tf.keras.optimizers.SGD(learning_rate=0.1),
# Keras comes with built-in MSE error
# However, you could use the loss function
# defined above
loss=tf.keras.losses.mean_squared_error,
)
КерасfitОжидается, что пакетные данные или полный набор данных в качестве массива Numpy. Массивы Numpy нарезаны на партии и по умолчанию до пакетного размера 32.
В этом случае, чтобы соответствовать поведению рукописной петли, вы должны пройтиxв одной партии размера 1000.
print(x.shape[0])
keras_model.fit(x, y, epochs=10, batch_size=1000)
Обратите внимание, что Керас распечатывает потерю после обучения, а не раньше, поэтому первая потеря кажется ниже, но в остальном это показывает по сути такую же обучение.
Следующие шаги
В этом руководстве вы видели, как использовать основные классы тензоров, переменных, модулей и градиентной ленты для создания и обучения модели, и, кроме того, как эти идеи отображают кера.
Это, однако, чрезвычайно простая проблема. Для более практичного введения, см.Пользовательское обучениеПолем
Для получения дополнительной информации об использовании встроенных петли обучения кераса, см.это руководствоПолем Для получения дополнительной информации о тренировочных петлях и керах, посмотритеэто руководствоПолем Для написания пользовательских распределенных тренировочных циклов см.это руководствоПолем
Первоначально опубликовано на
Оригинал