Учебники

8) Линейная регрессия

Февраль 11, 2020

TensorFlow предоставляет инструменты для полного контроля над вычислениями. Это делается с помощью низкоуровневого API. Кроме того, TensorFlow оснащен широким набором API для выполнения многих алгоритмов машинного обучения. Это API высокого уровня. TensorFlow называет их оценщиками

  • Низкоуровневый API: построение архитектуры, оптимизация модели с нуля. Это сложно для начинающего
  • API высокого уровня: определите алгоритм. Это легкое в использовании. TensorFlow предоставляет инструмент оценки вызовов инструментов для построения, обучения, оценки и прогнозирования.

В этом уроке вы будете использовать только оценки . Вычисления быстрее и проще в реализации. Первая часть руководства объясняет, как использовать оптимизатор градиентного спуска для обучения линейной регрессии. Во второй части вы будете использовать набор данных Бостона, чтобы предсказать цену дома, используя оценщик TensorFlow.

Скачать Бостон DataSet

В этом уроке вы узнаете:

Как обучить модели линейной регрессии

Прежде чем мы начнем обучать модель, давайте посмотрим, что такое линейная регрессия.

Представьте, что у вас есть две переменные, x и y, и ваша задача — предсказать значение знания значения. Если вы нанесете данные на график, вы увидите положительную связь между вашей независимой переменной x и зависимой переменной y.

Вы можете наблюдать, что если x = 1, y будет примерно равен 6, а если x = 2, y будет около 8,5.

Это не очень точный метод и подвержен ошибкам, особенно с набором данных с сотнями тысяч точек.

Линейная регрессия оценивается с помощью уравнения. Переменная y объясняется одним или несколькими ковариатами. В вашем примере есть только одна зависимая переменная. Если вам нужно написать это уравнение, оно будет:

С:

  • это уклон т.е. если x = 0, y =
  • это вес, связанный с х
  • является невязкой или ошибкой модели. Включает в себя то, что модель не может извлечь из данных

Представьте, что вы подходите под модель, и вы найдете следующее решение для:

  • = 3,8
  • = 2,78

Вы можете заменить эти числа в уравнении, и оно становится:

у = 3,8 + 2,78х

Теперь у вас есть лучший способ найти значения для y. То есть вы можете заменить x любым значением, которое вы хотите предсказать y. На изображении ниже мы заменили x в уравнении всеми значениями в наборе данных и построили график.

Красная линия представляет подогнанное значение, то есть значения y для каждого значения x. Вам не нужно видеть значение x, чтобы предсказать y, для каждого x есть любое, которое принадлежит красной линии. Вы также можете прогнозировать значения х выше 2!

Если вы хотите расширить линейную регрессию на большее число ковариат, вы можете добавить больше переменных в модель. Разница между традиционным анализом и линейной регрессией заключается в том, что линейная регрессия смотрит на то, как у отреагирует на каждую переменную х, взятую независимо.

Давайте посмотрим на пример. Представьте, что вы хотите предсказать продажи магазина мороженого. Набор данных содержит различную информацию, такую ​​как погода (т. Е. Дождливая, солнечная, облачная), информация о клиентах (т. Е. Зарплата, пол, семейное положение).

Традиционный анализ будет пытаться предсказать продажу, скажем, вычисляя среднее значение для каждой переменной, и попытаться оценить продажу для различных сценариев. Это приведет к плохим прогнозам и ограничит анализ выбранным сценарием.

Если вы используете линейную регрессию, вы можете написать это уравнение:

Алгоритм найдет лучшее решение для весов; это означает, что он попытается минимизировать стоимость (разницу между установленной линией и точками данных).

Как работает алгоритм

Алгоритм выберет случайное число для каждого и заменит значение x, чтобы получить прогнозируемое значение y. Если набор данных имеет 100 наблюдений, алгоритм вычисляет 100 предсказанных значений.

Мы можем вычислить ошибку, отмеченную для модели, которая представляет собой разницу между прогнозируемым значением и реальным значением. Положительная ошибка означает, что модель недооценивает прогноз y, а отрицательная ошибка означает, что модель переоценивает прогноз y.

Ваша цель — минимизировать квадрат ошибки. Алгоритм вычисляет среднее значение квадратной ошибки. Этот шаг называется минимизацией ошибки. Для линейной регрессии используется среднеквадратичная ошибка , также называемая MSE. Математически это:

Куда:

  • это вес, так относится к прогнозируемому значению
  • у реальные значения
  • m — количество наблюдений

Обратите внимание, что это означает, что он использует транспонирование матриц. Это математическое обозначение среднего.

Цель состоит в том, чтобы найти лучшее, что минимизирует MSE

Если средняя ошибка велика, это означает, что модель работает плохо и веса не выбраны правильно. Чтобы исправить вес, вам нужно использовать оптимизатор. Традиционный оптимизатор называется Gradient Descent .

Градиентный спуск принимает производную и уменьшает или увеличивает вес. Если производная положительна, вес уменьшается. Если производная отрицательна, вес увеличивается. Модель обновит вес и пересчитает ошибку. Этот процесс повторяется до тех пор, пока ошибка больше не изменится. Каждый процесс называется итерацией . Кроме того, градиенты умножаются на скорость обучения. Это указывает на скорость обучения.

Если скорость обучения слишком мала, алгоритм сходится очень долго (т.е. требует много итераций). Если скорость обучения слишком высока, алгоритм может никогда не сходиться.

Как видно из рисунка выше, модель повторяет процесс примерно 20 раз, прежде чем найти стабильное значение для весов, следовательно, достигая наименьшей ошибки.

Обратите внимание , что ошибка не равна нулю, а стабилизируется около 5. Это означает, что модель допускает типичную ошибку 5. Если вы хотите уменьшить ошибку, вам нужно добавить больше информации в модель, например, больше переменных или использовать разные оценки.

Вы помните первое уравнение

Окончательные веса 3,8 и 2,78. Видео ниже показывает, как градиентный спуск оптимизирует функцию потерь, чтобы найти этот вес

Как обучить линейной регрессии с TensorFlow

Теперь, когда вы лучше понимаете, что происходит за укрытием, вы готовы использовать API оценки, предоставленный TensorFlow, для обучения вашей первой линейной регрессии.

Вы будете использовать Бостонский набор данных, который включает в себя следующие переменные

CRIM уровень преступности на душу населения по городам
гп доля жилой земли зонирована под участки более 25 000 кв. футов.
промышл доля не розничных торговых площадей на город.
NOx концентрация окислов азота
комната среднее количество комнат в доме
возраст доля домовладельцев, построенных до 1940 года
дис взвешенные расстояния до пяти бостонских центров занятости
налог ставка налога на имущество на полную стоимость за доллары 10000
ptratio Соотношение учеников и учителей по городам
MEDV Средняя стоимость домов, занимаемых владельцами, в тысячах долларов

Вы создадите три разных набора данных:

Набор данных задача форма
Подготовка Тренируй модель и получай весы 400, 10
оценка Оцените производительность модели на невидимых данных 100, 10
прогнозировать Используйте модель, чтобы предсказать ценность дома на новых данных 6, 10

Задача состоит в том, чтобы использовать особенности набора данных для прогнозирования стоимости дома.

Во второй части учебника вы узнаете, как использовать TensorFlow с тремя различными способами импорта данных:

  • С пандами
  • С Numpy
  • Только TF

Обратите внимание, что все параметры дают одинаковые результаты.

Вы узнаете, как использовать высокоуровневый API для построения и обучения модели линейной регрессии. Если вы использовали низкоуровневый API, вы должны были определить вручную:

  • Функция потери
  • Оптимизировать: градиентный спуск
  • Умножение матриц
  • График и тензор

Это утомительно и сложнее для новичка.

Панды

Вам необходимо импортировать необходимые библиотеки для обучения модели.

import pandas as pd
from sklearn import datasets
import tensorflow as tf
import itertools

Шаг 1) Импортируйте данные с помощью panda.

Вы определяете имена столбцов и сохраняете их в COLUMNS. Вы можете использовать pd.read_csv () для импорта данных.

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
           "dis", "tax", "ptratio", "medv"]

training_set = pd.read_csv («E: /boston_train.csv», skipinitialspace = True, skiprows = 1, names = COLUMNS)

test_set = pd.read_csv («E: /boston_test.csv», skipinitialspace = True, skiprows = 1, names = COLUMNS)

pretiontion_set = pd.read_csv («E: /boston_predict.csv», skipinitialspace = True, skiprows = 1, names = COLUMNS)

Вы можете распечатать форму данных. 

print(training_set.shape, test_set.shape, prediction_set.shape)

Вывод

(400, 10) (100, 10) (6, 10)

Обратите внимание, что метка, т. Е. Ваш y, включена в набор данных. Так что вам нужно определить два других списка. Один, содержащий только функции, а другой только с названием этикетки. Эти два списка сообщат вашему оценщику, какие функции в наборе данных и какое имя столбца является меткой

Это делается с помощью кода ниже. 

FEATURES = ["crim", "zn", "indus", "nox", "rm",				
                 "age", "dis", "tax", "ptratio"]
LABEL = "medv"

Шаг 2) Конвертировать данные

Вам необходимо преобразовать числовые переменные в правильный формат. Tensorflow предоставляет метод для преобразования непрерывной переменной: tf.feature_column.numeric_column ().

На предыдущем шаге вы определяете список объектов, которые хотите включить в модель. Теперь вы можете использовать этот список для преобразования их в числовые данные. Если вы хотите исключить объекты в вашей модели, не стесняйтесь удалить одну или несколько переменных в списке ОСОБЕННОСТИ, прежде чем создавать feature_cols

Обратите внимание, что вы будете использовать понимание списка Python со списком FEATURES для создания нового списка с именем feature_cols. Это поможет вам не писать девять раз tf.feature_column.numeric_column (). Понимание списка — это более быстрый и чистый способ создания новых списков.

feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]

Шаг 3) Определите оценщик

На этом этапе вам необходимо определить оценщик. В настоящее время Tensorflow предоставляет 6 готовых оценок, в том числе 3 для задачи классификации и 3 для задачи регрессии:

  • REGRESSOR
    • DNNRegressor
    • LinearRegressor
    • DNNLineaCombinedRegressor
  • классификатор
    • DNNClassifier
    • LinearClassifier
    • DNNLineaCombinedClassifier

В этом уроке вы будете использовать линейный регрессор. Чтобы получить доступ к этой функции, вам необходимо использовать tf.estimator.

Функция нуждается в двух аргументах:

  • feature_columns: содержит переменные для включения в модель
  • model_dir: путь для сохранения графика, сохранения параметров модели и т. д.

Tensorflow автоматически создаст файл с именем train в вашем рабочем каталоге. Вы должны использовать этот путь для доступа к Tensorboard.

estimator = tf.estimator.LinearRegressor(    
        feature_columns=feature_cols,   
        model_dir="train")

Вывод 

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a215dc550>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Сложная часть с TensorFlow — способ кормить модель. Tensorflow предназначен для работы с параллельными вычислениями и очень большим набором данных. Из-за ограниченности ресурсов машины невозможно снабдить модель всеми данными одновременно. Для этого вам нужно каждый раз подавать пакет данных. Обратите внимание, что речь идет об огромном наборе данных с миллионами и более записями. Если вы не добавите пакет, вы получите ошибку памяти.

Например, если ваши данные содержат 100 наблюдений, и вы определяете размер партии 10, это означает, что модель будет видеть 10 наблюдений для каждой итерации (10 * 10).

Когда модель увидела все данные, она заканчивает одну эпоху . Время определяет, сколько раз вы хотите, чтобы модель видела данные. Лучше установить этот шаг равным none и позволить модели выполнять количество итераций времени.

Вторая информация, которую нужно добавить, — это если вы хотите перемешать данные перед каждой итерацией. Во время обучения важно перетасовать данные, чтобы модель не изучала конкретную структуру набора данных. Если модель узнает детали базового шаблона данных, ей будет сложно обобщить прогноз для невидимых данных. Это называется переоснащением . Модель хорошо работает с данными обучения, но не может правильно прогнозировать невидимые данные.

TensorFlow упрощает выполнение этих двух шагов. Когда данные поступают в конвейер, они знают, сколько наблюдений им нужно (пакетно) и нужно ли им перетасовывать данные.

Чтобы указать Tensorflow, как кормить модель, вы можете использовать pandas_input_fn. Этому объекту нужно 5 параметров:

  • х: особенность данных
  • y: данные метки
  • batch_size: партия. По умолчанию 128
  • num_epoch: количество эпох, по умолчанию 1
  • перемешать: перемешать или нет данные. По умолчанию нет

Вам нужно многократно кормить модель, чтобы определить функцию для повторения этого процесса. вся эта функция get_input_fn.

def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):    
         return tf.estimator.inputs.pandas_input_fn(       
         x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),       
         y = pd.Series(data_set[LABEL].values),       
         batch_size=n_batch,          
         num_epochs=num_epochs,       
         shuffle=shuffle)

Обычный метод оценки производительности модели:

  • Тренируй модель
  • Оценить модель в другом наборе данных
  • Сделать прогноз

Оценщик Tensorflow предоставляет три различные функции для простого выполнения этих трех этапов.

Шаг 4) : тренировка модели

Вы можете использовать оценочный поезд для оценки модели. Оценщик поезда нуждается в input_fn и ряде шагов. Вы можете использовать функцию, которую вы создали выше, чтобы кормить модель. Затем вы даете команду модели повторяться 1000 раз. Обратите внимание, что вы не указываете количество эпох, вы позволяете модели повторяться 1000 раз. Если вы установите число эпох на 1, то модель будет повторяться 4 раза: в обучающем наборе 400 записей, а размер пакета равен 128.

  1. 128 строк
  2. 128 строк
  3. 128 строк
  4. 16 рядов

Следовательно, проще установить число эпох и не указывать число итераций. 

estimator.train(input_fn=get_input_fn(training_set,                                       
                                           num_epochs=None,                                      
                                           n_batch = 128,                                      
                                           shuffle=False),                                      
                                           steps=1000)

Вывод 

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 238.616
INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)
INFO:tensorflow:global_step/sec: 314.293
INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)
INFO:tensorflow:global_step/sec: 303.863
INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)
INFO:tensorflow:global_step/sec: 308.782
INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)
INFO:tensorflow:global_step/sec: 244.969
INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)
INFO:tensorflow:global_step/sec: 155.966
INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)
INFO:tensorflow:global_step/sec: 263.256
INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)
INFO:tensorflow:global_step/sec: 254.112
INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)
INFO:tensorflow:global_step/sec: 292.405
INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec)
INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt.
INFO:tensorflow:Loss for final step: 5925.9873.

Вы можете проверить Tensorboard с помощью следующей команды: 

activate hello-tf
# For MacOS
tensorboard --logdir=./train
# For Windows
tensorboard --logdir=train

Шаг 5) Оцените вашу модель

Вы можете оценить соответствие вашей модели на тестовом наборе с помощью кода ниже: 

ev = estimator.evaluate(    
          input_fn=get_input_fn(test_set,                          
          num_epochs=1,                          
          n_batch = 128,                          
          shuffle=False))

Вывод 

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896

Вы можете распечатать потери с кодом ниже: 

loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))

Вывод 

Loss: 3215.895996

У модели потеря 3215. Вы можете проверить сводную статистику, чтобы понять, насколько велика ошибка. 

training_set['medv'].describe()

Вывод 

count    400.000000
mean      22.625500
std        9.572593
min        5.000000
25%       16.600000
50%       21.400000
75%       25.025000
max       50.000000
Name: medv, dtype: float64

Из приведенной выше сводной статистики вы знаете, что средняя цена дома составляет 22 тысячи, минимальная цена составляет 9 тысяч, а максимальная — 50 тысяч. Модель совершает типичную ошибку в 3к долларов.

Шаг 6) Сделайте прогноз

Наконец, вы можете использовать прогноз оценки, чтобы оценить стоимость 6 бостонских домов. 

y = estimator.predict(    
         input_fn=get_input_fn(prediction_set,                          
         num_epochs=1,                          
         n_batch = 128,                          
         shuffle=False))

Чтобы распечатать оценочные значения, вы можете использовать этот код: 

predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

Вывод 

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]

Модель прогнозирует следующие значения:

жилой дом

прогнозирование

1

32,29

2

18,96

3

27,27

4

29,29

5

16,43

7

21,46

Обратите внимание, что мы не знаем истинное значение. В уроке глубокого обучения вы попробуете побить линейную модель

Numpy Solution

В этом разделе объясняется, как обучать модель, используя для оценки данных числовую оценку. Метод тот же, за исключением того, что вы будете использовать оценщик numpy_input_fn.

training_set_n = pd.read_csv («E: /boston_train.csv»). значения

test_set_n = pd.read_csv («E: /boston_test.csv»). значения

Предсказание_set_n = pd.read_csv («E: /boston_predict.csv»). значения

Шаг 1) Импортируйте данные

Прежде всего, вам необходимо отличить переменные объекта от метки. Вы должны сделать это для данных обучения и оценки. Это быстрее, чтобы определить функцию для разделения данных.

def prepare_data(df):     
        X_train = df[:, :-3]    
        y_train = df[:,-3]    
        return X_train, y_train

Вы можете использовать функцию, чтобы отделить метку от особенностей поезда / оценить набор данных 

X_train, y_train = prepare_data(training_set_n)
X_test, y_test = prepare_data(test_set_n)

Вам необходимо исключить последний столбец набора данных прогноза, поскольку он содержит только NaN 

x_predict = prediction_set_n[:, :-2]

Подтвердите форму массива. Обратите внимание, что метка не должна иметь размерности, это означает (400,).

print(X_train.shape, y_train.shape, x_predict.shape)

Вывод 

(400, 9) (400,) (6, 9)

Вы можете построить столбцы объектов следующим образом: 

feature_columns = [      tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]

Оценщик определен, как и раньше, вы указываете столбцы объектов и куда сохранять график. 

estimator = tf.estimator.LinearRegressor(    
         feature_columns=feature_columns,    
         model_dir="train1")

Вывод 

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a218d8f28>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Вы можете использовать числовую оценку, чтобы подать данные в модель, а затем обучить модель. Обратите внимание, что мы определяем функцию input_fn прежде, чтобы облегчить читабельность.

# Train the estimatortrain_input = tf.estimator.inputs.numpy_input_fn(   
           x={"x": X_train},    
           y=y_train,    
           batch_size=128,    
           shuffle=False,    
           num_epochs=None)
           estimator.train(input_fn = train_input,steps=5000)

Вывод 

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train1/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 490.057
INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)
INFO:tensorflow:global_step/sec: 788.986
INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)
INFO:tensorflow:global_step/sec: 736.339
INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)
INFO:tensorflow:global_step/sec: 383.305
INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)
INFO:tensorflow:global_step/sec: 859.832
INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)
INFO:tensorflow:global_step/sec: 804.394
INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)
INFO:tensorflow:global_step/sec: 753.059
INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)
INFO:tensorflow:global_step/sec: 402.165
INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)
INFO:tensorflow:global_step/sec: 344.022
INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec)
INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt.
INFO:tensorflow:Loss for final step: 5925.985.
Out[23]:
<tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1b6ea860>

Вы повторяете тот же шаг с другим оценщиком, чтобы оценить вашу модель 

eval_input = tf.estimator.inputs.numpy_input_fn(    
       x={"x": X_test},    
       y=y_test, 
       shuffle=False,    
       batch_size=128,    
       num_epochs=1)
   estimator.evaluate(eval_input,steps=None)

Вывод 

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945
Out[24]:
{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}

Наконец, вы можете вычислить прогноз. Это должно быть похоже на панд.

test_input = tf.estimator.inputs.numpy_input_fn(    
        x={"x": x_predict},    
        batch_size=128,    
        num_epochs=1,   
        shuffle=False)
        y = estimator.predict(test_input) 			
predictions = list(p["predictions"] for p in itertools.islice(y, 6))
print("Predictions: {}".format(str(predictions)))

Вывод 

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]

Tensorflow решение

Последний раздел посвящен решению TensorFlow. Этот метод чуть сложнее, чем другой.

Обратите внимание, что если вы используете ноутбук Jupyter, вам нужно перезагрузить и очистить ядро, чтобы запустить этот сеанс.

TensorFlow создал отличный инструмент для передачи данных в конвейер. В этом разделе вы создадите функцию input_fn самостоятельно.

Шаг 1) Определите путь и формат данных

Прежде всего, вы объявляете две переменные с путем файла CSV. Обратите внимание, что у вас есть два файла, один для обучающего набора и один для испытательного набора.

import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"

Затем вам нужно определить столбцы, которые вы хотите использовать из файла CSV. Мы будем использовать все. После этого вам необходимо объявить тип переменной.

Переменная с плавающей точкой определяется как [0.] 

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",				
                "dis", "tax", "ptratio", "medv"]RECORDS_ALL = [[0.0], [0.0], [0.0], [0.0],[0.0],[0.0],[0.0],[0.0],[0.0],[0.0]]

Шаг 2) Определите функцию input_fn

Функция может быть разбита на три части:

  1. Импортировать данные
  2. Создать итератор
  3. Потреблять данные

Ниже приведен общий код для определения функции. Код будет объяснен после

def input_fn(data_file, batch_size, num_epoch = None):				
       # Step 1				
          def parse_csv(value):        
          columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)        
          features = dict(zip(COLUMNS, columns))				
          #labels = features.pop('median_house_value')        
          labels =  features.pop('medv')        
          return features, labels							
          
          # Extract lines from input files using the 
          Dataset API.    dataset = (tf.data.TextLineDataset(data_file) # Read text file       
          .skip(1) # Skip header row       
          .map(parse_csv))			   
          
          dataset = dataset.repeat(num_epoch)    
          dataset = dataset.batch(batch_size) 				
          # Step 3    
          iterator = dataset.make_one_shot_iterator()    
          features, labels = iterator.get_next()    
          return features, labels

** Импорт данных **

Для файла csv метод набора данных читает по одной строке за раз. Чтобы построить набор данных, вам нужно использовать объект TextLineDataset. Ваш набор данных имеет заголовок, поэтому вам нужно использовать skip (1), чтобы пропустить первую строку. На этом этапе вы только читаете данные и исключаете заголовок в конвейере. Для подачи модели вам необходимо отделить элементы от метки. Метод, применяемый для применения любого преобразования к данным, — это карта.

Этот метод вызывает функцию, которую вы создадите, чтобы указать, как преобразовать данные. В двух словах, вам нужно передать данные в объект TextLineDataset, исключить заголовок и применить преобразование, которое инструктируется объяснением функции. Код

  • tf.data.TextLineDataset (data_file): эта строка читает файл csv
  • .skip (1): пропустить заголовок
  • .map (parse_csv)): разбить записи на тензоры. Вам нужно определить функцию для инструктирования объекта карты. Вы можете вызвать эту функцию parse_csv.

Эта функция анализирует файл csv с помощью метода tf.decode_csv и объявляет функции и метку. Функции могут быть объявлены как словарь или кортеж. Вы используете метод словаря, потому что это более удобно. Объяснение кода

  • tf.decode_csv (value, record_defaults = RECORDS_ALL): метод decode_csv использует выходные данные TextLineDataset для чтения файла csv. record_defaults сообщает TensorFlow о типе столбцов.
  • dict (zip (_CSV_COLUMNS, columns)): заполнить словарь всеми столбцами, извлеченными во время этой обработки данных
  • features.pop (‘median_house_value’): исключить целевую переменную из переменной объекта и создать переменную метки

Набор данных нуждается в дополнительных элементах для итеративной подачи тензоров. Действительно, вам нужно добавить метод repeat, чтобы позволить набору данных продолжать работу модели в течение неопределенного времени. Если вы не добавите метод, модель будет повторяться только один раз, а затем выдаст ошибку, потому что в конвейер больше не подается никаких данных.

После этого вы можете контролировать размер партии с помощью метода партии. Это означает, что вы указываете набору данных, сколько данных вы хотите передать в конвейере для каждой итерации. Если вы установите большой размер партии, модель будет работать медленно.

Шаг 3) Создайте итератор

Теперь вы готовы ко второму шагу: создайте итератор для возврата элементов в наборе данных.

Самым простым способом создания оператора является метод make_one_shot_iterator.

После этого вы можете создавать элементы и метки из итератора.

Шаг 4) Потребление данных

Вы можете проверить, что происходит с функцией input_fn. Вам нужно вызвать функцию в сеансе, чтобы использовать данные. Вы пытаетесь с размером партии равным 1.

Обратите внимание, что он печатает объекты в словаре и метку в виде массива.

Он покажет первую строку файла CSV. Вы можете попытаться запустить этот код много раз с разным размером пакета.

next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)
with tf.Session() as sess:    
     first_batch  = sess.run(next_batch)    
     print(first_batch)

Вывод 

({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))

Шаг 4) Определите колонку объектов

Вы должны определить числовые столбцы следующим образом: 

X1= tf.feature_column.numeric_column('crim')
X2= tf.feature_column.numeric_column('zn')
X3= tf.feature_column.numeric_column('indus')
X4= tf.feature_column.numeric_column('nox')
X5= tf.feature_column.numeric_column('rm')
X6= tf.feature_column.numeric_column('age')
X7= tf.feature_column.numeric_column('dis')
X8= tf.feature_column.numeric_column('tax')
X9= tf.feature_column.numeric_column('ptratio')

Обратите внимание, что вам нужно объединить все переменные в ведре 

base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]

Шаг 5) Постройте модель

Вы можете обучить модель с оценщиком LinearRegressor. 

model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')

Вывод 

INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': 'train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820a010f0>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Вам нужно использовать лямбда-функцию, чтобы позволить записать аргумент в функции inpu_fn. Если вы не используете лямбда-функцию, вы не можете тренировать модель.

# Train the estimatormodel.train(steps =1000,    
          input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))

Вывод 

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into train3/model.ckpt.
INFO:tensorflow:loss = 83729.64, step = 1
INFO:tensorflow:global_step/sec: 72.5646
INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)
INFO:tensorflow:global_step/sec: 101.355
INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)
INFO:tensorflow:global_step/sec: 109.293
INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)
INFO:tensorflow:global_step/sec: 102.235
INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)
INFO:tensorflow:global_step/sec: 104.656
INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)
INFO:tensorflow:global_step/sec: 106.697
INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)
INFO:tensorflow:global_step/sec: 118.454
INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)
INFO:tensorflow:global_step/sec: 114.947
INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)
INFO:tensorflow:global_step/sec: 111.484
INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec)
INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt.
INFO:tensorflow:Loss for final step: 5925.9873.
Out[8]:
<tensorflow.python.estimator.canned.linear.LinearRegressor at 0x18225eb8d0>

Вы можете оценить соответствие вашей модели на тестовом наборе с помощью кода ниже: 

results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))
for key in results:   
print("   {}, was: {}".format(key, results[key]))

Вывод 

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896
   average_loss, was: 32.158958435058594
   loss, was: 3215.89599609375
   global_step, was: 1000

Последним шагом является прогнозирование стоимости на основе стоимости, матрицы функций. Вы можете написать словарь со значениями, которые вы хотите предсказать. Ваша модель имеет 9 функций, поэтому вам нужно предоставить значение для каждой. Модель предоставит прогноз для каждого из них.

В приведенном ниже коде вы записали значения каждой функции, содержащейся в файле df_predict csv.

Вам нужно написать новую функцию input_fn, потому что в наборе данных нет метки. Вы можете использовать API from_tensor из набора данных.

prediction_input = {				
          'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],				
          'zn': [75.0,0.0,25.0,33.0,0.0,0.0],				
          'indus': [2.95,18.10,5.13,2.18,18.10,9.90],				
          'nox': [0.428,0.713,0.453,0.472,0.700,0.544],				
          'rm': [7.024,6.297,6.762,7.236,5.390,5.782],				
          'age': [15.8,91.8,43.4,41.1,98.9,71.7],				
          'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],				
          'tax': [252,666,284,222,666,304],				
          'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]
     }
     def test_input_fn():    
     dataset = tf.data.Dataset.from_tensors(prediction_input)    
     return dataset
     
     # Predict all our prediction_inputpred_results = model.predict(input_fn=test_input_fn)

Наконец, вы печатаете прогнозы. 

for pred in enumerate(pred_results):    
print(pred)

Вывод 

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
(0, {'predictions': array([32.297546], dtype=float32)})
(1, {'predictions': array([18.96125], dtype=float32)})
(2, {'predictions': array([27.270979], dtype=float32)})
(3, {'predictions': array([29.299236], dtype=float32)})
(4, {'predictions': array([16.436684], dtype=float32)})
(5, {'predictions': array([21.460876], dtype=float32)})

INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})

Резюме

Чтобы обучить модель, вам необходимо:

  • Определите функции: Независимые переменные: X
  • Определите метку: зависимая переменная: y
  • Построить поезд / испытательный комплекс
  • Определите начальный вес
  • Определить функцию потерь: MSE
  • Оптимизация модели: градиентный спуск
  • Определение:
    • Скорость обучения
    • Количество эпох
    • Размер партии

В этом руководстве вы узнали, как использовать API высокого уровня для оценки линейной регрессии. Вам необходимо определить:

  1. Особые столбцы. Если непрерывно: tf.feature_column.numeric_column (). Вы можете заполнить список с пониманием списка Python
  2. Оценщик: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Функция для импорта данных, размера пакета и эпохи: input_fn ()

После этого вы готовы тренироваться, оценивать и делать прогнозы с помощью train (), оценивать () и прогнозировать ()

 

45
Share: