Линейна регресия с TensorFlow (примери)

Съдържание:

Anonim

Какво е линейна регресия?

Линейната регресия е подход в статистиката за моделиране на връзките между две променливи. Това моделиране се извършва между скаларен отговор и една или повече обяснителни променливи. Връзката с една обяснителна променлива се нарича проста линейна регресия, а за повече от една обяснителна променлива се нарича множествена линейна регресия.

TensorFlow предоставя инструменти за пълен контрол на изчисленията. Това се прави с API на ниско ниво. На всичкото отгоре TensorFlow е снабден с богат набор от API за изпълнение на много алгоритми за машинно обучение. Това е API на високо ниво. TensorFlow ги нарича оценители

  • API на ниско ниво: Изградете архитектурата, оптимизиране на модела от нулата. Сложно е за начинаещи
  • API на високо ниво: Дефинирайте алгоритъма. Той е по-лесен за употреба. TensorFlow предоставя инструментариум разговори в оценителя на конструкция, влак, да оценяват и да направи прогноза.

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

Изтеглете Boston DataSet

В този урок за регресия на TensorFlow ще научите:

  • Какво е линейна регресия?
  • Как да тренирам модел на линейна регресия
  • Как да тренираме линейна регресия с TensorFlow
  • Панди
  • Решение на Numpy
  • Разтвор на Tensorflow

Как да тренирам модел на линейна регресия

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

Представете си, че имате две променливи, x и y и вашата задача е да предскажете стойността на познаването на стойността на. Ако начертаете данните, можете да видите положителна връзка между вашата независима променлива x и зависимата ви променлива y.

Може да забележите, че ако x = 1, y приблизително ще бъде равно на 6, а ако x = 2, y ще бъде около 8,5.

Това не е много точен метод и е склонен към грешки, особено при набор от данни със стотици хиляди точки.

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

С:

  • е теглото, свързано с x
  • е остатъкът или грешката на модела. Той включва това, което моделът не може да научи от данните

Представете си, че отговаряте на модела и ще намерите следното решение за:

  • = 3,8
  • = 2,78

Можете да замените тези числа в уравнението и то става:

y = 3,8 + 2,78x

Вече имате по-добър начин да намерите стойностите за y. Тоест, можете да замените x с всяка стойност, която искате да предскажете y. На изображението по-долу заместваме x в уравнението с всички стойности в набора от данни и начертаваме резултата.

Червената линия представлява монтираната стойност, т.е. стойностите на y за всяка стойност на x. Не е нужно да виждате стойността на x, за да предскажете y, за всеки x има всеки, който принадлежи на червената линия. Можете също така да предсказвате за стойности на х по-високи от 2!

Ако искате да разширите линейната регресия до повече ковариации, можете, като добавите повече променливи към модела. Разликата между традиционния анализ и линейната регресия е, че линейната регресия разглежда как y ще реагира за всяка променлива x, взета независимо.

Да видим пример. Представете си, че искате да предскажете продажбите на магазин за сладолед. Наборът от данни съдържа различна информация като времето (т.е. дъждовно, слънчево, облачно), информация за клиентите (т.е. заплата, пол, семейно положение).

Традиционният анализ ще се опита да предскаже продажбата, като кажем, че изчислява средната стойност за всяка променлива и ще се опита да оцени продажбата за различни сценарии. Това ще доведе до лоши прогнози и ще ограничи анализа до избрания сценарий.

Ако използвате линейна регресия, можете да напишете това уравнение:

Алгоритъмът ще намери най-доброто решение за тежестите; това означава, че ще се опита да минимизира разходите (разликата между монтираната линия и точките с данни).

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

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

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

Вашата цел е да минимизирате квадрата на грешката. Алгоритъмът изчислява средната стойност на квадратната грешка. Тази стъпка се нарича минимизиране на грешката. За линейна регресия е средната квадратна грешка , наричана още MSE. Математически това е:

Където:

  • отнася до предсказаната стойност
  • y е реалните стойности
  • m е броят на наблюденията

Имайте предвид, че е математическата нотация на средната стойност.

Целта е да се намери най-доброто, което да сведе до минимум MSE

Ако средната грешка е голяма, това означава, че моделът се представя лошо и тежестите не са избрани правилно. За да коригирате тежестите, трябва да използвате оптимизатор. Традиционният оптимизатор се нарича Gradient Descent .

Градиентното спускане взема производното и намалява или увеличава теглото. Ако производното е положително, теглото се намалява. Ако производното е отрицателно, теглото се увеличава. Моделът ще актуализира теглата и ще преизчисли грешката. Този процес се повтаря, докато грешката вече не се промени. Всеки процес се нарича итерация . Освен това градиентите се умножават по степен на обучение. Той показва скоростта на обучение.

Ако скоростта на обучение е твърде малка, ще отнеме много време, докато алгоритъмът се сближи (т.е. изисква много итерации). Ако скоростта на обучение е твърде висока, алгоритъмът може никога да не се сближи.

Виждате от снимката по-горе, моделът повтаря процеса около 20 пъти преди да намери стабилна стойност за тежестите, следователно достигайки най-ниската грешка.

Имайте предвид , че грешката не е равна на нула, но се стабилизира около 5. Това означава, че моделът прави типична грешка от 5. Ако искате да намалите грешката, трябва да добавите повече информация към модела, като повече променливи или да използвате различни оценители.

Помните първото уравнение

Крайните тегла са 3.8 и 2.78. Видеото по-долу ви показва как градиентното спускане оптимизира функцията за загуба, за да намери това тегло

Как да тренираме линейна регресия с TensorFlow

След като вече разбирате по-добре какво се случва зад капака, вие сте готови да използвате API за оценка, предоставен от TensorFlow, за да обучите първата си линейна регресия с помощта на TensorFlow.

Ще използвате набора от данни в Бостън, който включва следните променливи

престъпна процент на престъпност на глава от населението по градове
zn дял жилищна земя, зонирана за парцели над 25 000 кв.ф.
indus делът на бизнес акра за продажба на дребно на град.
нокс концентрация на азотни оксиди
rm среден брой стаи на жилище
възраст дял на заетите от собствениците единици, построени преди 1940 г.
дис претеглени разстояния до пет центъра за заетост в Бостън
данък пълна стойност на данъка върху имуществото на 10 000 долара
ptratio съотношение ученик-учител по град
medv Средна стойност на обитаваните от собствениците домове в хиляди долари

Ще създадете три различни набора от данни:

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

Целите са да се използват характеристиките на набора от данни, за да се предскаже стойността на къщата.

По време на втората част на урока ще научите как да използвате TensorFlow с три различни начина за импортиране на данните:

  • С Панди
  • С Numpy
  • Само TF

Имайте предвид, че всички опции дават еднакви резултати.

Ще научите как да използвате API на високо ниво за изграждане, обучение на оценка на модел на линейна регресия TensorFlow. Ако използвате API на ниско ниво, трябваше да дефинирате на ръка:

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

Това е досадно и по-сложно за начинаещи.

Панди

Трябва да импортирате необходимите библиотеки, за да обучите модела.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Стъпка 1) Импортирайте данните с panda.

Вие определяте имената на колоните и ги съхранявате в КОЛОНИ. Можете да използвате 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 = Вярно, skiprows = 1, имена = КОЛОНИ)

prediction_set = pd.read_csv ("E: /boston_predict.csv", skipinitialspace = Вярно, skiprows = 1, имена = КОЛОНИ)

Можете да отпечатате формата на данните.

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 ().

В предишната стъпка дефинирате списък на функция, която искате да включите в модела. Сега можете да използвате този списък, за да ги преобразувате в числови данни. Ако искате да изключите функции във вашия модел, не се колебайте да пуснете една или повече променливи в списъка ХАРАКТЕРИСТИКИ, преди да конструирате характеристиките_коли

Имайте предвид, че ще използвате разбирането на списъка на Python заедно със списъка ХАРАКТЕРИСТИКИ, за да създадете нов списък с имена feature_cols. Помага ви да избягвате да пишете девет пъти tf.feature_column.numeric_column (). Разбирането на списък е по-бърз и по-чист начин за създаване на нови списъци

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

Стъпка 3) Определете оценителя

В тази стъпка трябва да дефинирате оценителя. Понастоящем Tensorflow предоставя 6 предварително изградени оценки, включително 3 за задача за класификация и 3 за задача за регресия на TensorFlow:

  • Регресор
    • DNNRegressor
    • LinearRegressor
    • DNNLineaCombinedRegressor
  • Класификатор
    • Класификатор DNN
    • LinearClassifier
    • DNNLineaCombinedClassifier

В този урок ще използвате Linear Regressor. За достъп до тази функция трябва да използвате tf.estimator.

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

  • feature_columns: Съдържа променливите, които да бъдат включени в модела
  • model_dir: път за съхраняване на графиката, запазване на параметрите на модела и т.н.

Tensorflow автоматично ще създаде файл с име train във вашата работна директория. Трябва да използвате този път за достъп до Tensorboard, както е показано в долния пример за регресия на TensorFlow.

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': , '_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 параметъра:

  • x: данни за характеристиките
  • 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 реда

Следователно е по-лесно да зададете броя на епохата на нула и да дефинирате броя на итерациите, както е показано в th под примера за класификация на TensorFlow.

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 = 1INFO:tensorflow:global_step/sec: 238.616INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)INFO:tensorflow:global_step/sec: 314.293INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)INFO:tensorflow:global_step/sec: 303.863INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)INFO:tensorflow:global_step/sec: 308.782INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)INFO:tensorflow:global_step/sec: 244.969INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)INFO:tensorflow:global_step/sec: 155.966INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)INFO:tensorflow:global_step/sec: 263.256INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)INFO:tensorflow:global_step/sec: 254.112INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)INFO:tensorflow:global_step/sec: 292.405INFO: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 MacOStensorboard --logdir=./train# For Windowstensorboard --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:13INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13INFO: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.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: medv, dtype: float64

От обобщената статистика по-горе знаете, че средната цена за къща е 22 хиляди, с минимална цена от 9 хиляди и максимум 50 хиляди. Моделът прави типична грешка от 3 000 долара.

Стъпка 6) Направете прогнозата

И накрая, можете да използвате прогнозата TensorFlow, за да оцените стойността на 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-1000INFO: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

Този раздел обяснява как да обучите модела с помощта на numpy оценител за подаване на данните. Методът е същият освен, че ще използвате оценител numpy_input_fn.

training_set_n = pd.read_csv ("E: /boston_train.csv"). стойности

test_set_n = pd.read_csv ("E: /boston_test.csv"). стойности

prediction_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': , '_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}

Можете да използвате numpy оценка, за да подадете данните към модела и след това да обучите модела. Имайте предвид, че дефинираме функцията 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 = 1INFO:tensorflow:global_step/sec: 490.057INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)INFO:tensorflow:global_step/sec: 788.986INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)INFO:tensorflow:global_step/sec: 736.339INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)INFO:tensorflow:global_step/sec: 383.305INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)INFO:tensorflow:global_step/sec: 859.832INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)INFO:tensorflow:global_step/sec: 804.394INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)INFO:tensorflow:global_step/sec: 753.059INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)INFO:tensorflow:global_step/sec: 402.165INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)INFO:tensorflow:global_step/sec: 344.022INFO: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]:

Репликирате същата стъпка с различен оценител, за да оцените вашия модел

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:00INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945Out[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-1000INFO: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 файла. Ще използваме всички. След това трябва да декларирате типа на променливата, която е.

Променливата Floats се дефинира от [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 1def 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 theDataset 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 3iterator = dataset.make_one_shot_iterator()features, labels = iterator.get_next()return features, labels

** Импортиране на данните **

За csv файл методът на набора от данни чете по един ред. За да изградите набора от данни, трябва да използвате обекта TextLineDataset. Вашият набор от данни има заглавка, така че трябва да използвате skip (1), за да пропуснете първия ред. На този етап четете само данните и изключвате заглавката в конвейера. За да подадете модела, трябва да отделите функциите от етикета. Методът, използван за прилагане на всяка трансформация към данните, е map.

Този метод извиква функция, която ще създадете, за да инструктирате как да трансформирате данните. Накратко, трябва да предадете данните в обекта 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, колони)): Попълнете речника с всички колони, извлечени по време на тази обработка на данни
  • features.pop ('median_house_value'): Изключете целевата променлива от променливата на характеристиката и създайте променлива на етикет

Наборът от данни се нуждае от допълнителни елементи за итеративно захранване на тензорите. Всъщност трябва да добавите метода повторение, за да позволите набора от данни да продължи безкрайно, за да захрани модела. Ако не добавите метода, моделът ще повтори само веднъж и след това ще изведе грешка, тъй като в конвейера не се подават повече данни.

След това можете да контролирате размера на партидата с метода на партидата. Това означава, че казвате на набора от данни колко данни искате да предадете в конвейера за всяка итерация. Ако зададете голям размер на партидата, моделът ще бъде бавен.

Стъпка 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': , '_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 = 1INFO:tensorflow:global_step/sec: 72.5646INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)INFO:tensorflow:global_step/sec: 101.355INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)INFO:tensorflow:global_step/sec: 109.293INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)INFO:tensorflow:global_step/sec: 102.235INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)INFO:tensorflow:global_step/sec: 104.656INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)INFO:tensorflow:global_step/sec: 106.697INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)INFO:tensorflow:global_step/sec: 118.454INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)INFO:tensorflow:global_step/sec: 114.947INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)INFO:tensorflow:global_step/sec: 111.484INFO: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]:

Можете да оцените пригодността на вашия модел на тестовия комплект с кода по-долу:

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:02INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896average_loss, was: 32.158958435058594loss, was: 3215.89599609375global_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-1000INFO: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 на високо ниво за оценка на линейна регресия TensorFlow. Трябва да дефинирате:

  1. Колони с функции. Ако е непрекъснато: tf.feature_column.numeric_column (). Можете да попълните списък с разбиране на списъка на python
  2. Оценителят: tf.estimator.LinearRegressor (колони_на функции, модел_дир)
  3. Функция за импортиране на данните, размера на партидата и епохата: input_fn ()

След това сте готови да тренирате, оценявате и правите прогнози с train (), оценка () и прогнозиране ()