Цель этого руководства — сделать набор данных линейно разделимым. Учебник разделен на две части:

1. Преобразование функций
2. Обучите классификатор ядра с помощью Tensorflow

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

Зачем вам нужны методы ядра?

Цель каждого классификатора – правильно предсказать классы. Для этого набор данных должен быть разделимым. Посмотрите на график ниже; довольно просто увидеть, что все точки выше черной линии принадлежат к первому классу, а остальные точки ко второму классу. Однако такой простой набор данных встречается крайне редко. В большинстве случаев данные неразделимы. Методы ядра в машинном обучении создают трудности для наивных классификаторов, таких как логистическая регрессия.

import numpy as np
  import matplotlib.pyplot as plt
  from mpl_toolkits.mplot3d import Axes3D

  x_lin = np.array([1,2,3,4,5,6,7,8,9,10])
  y_lin = np.array([2,2,3,2,2,9,6,8,8,9])
  label_lin = np.array([0,0,0,0,0,1,1,1,1,1])
  
  fig = plt.figure()
  ax=fig.add_subplot(111)
  plt.scatter(x_lin, y_lin, c=label_lin, s=60)
  plt.plot([-2.5, 10], [12.5, -2.5], 'k-', lw=2)
  ax.set_xlim([-5,15])
  ax.set_ylim([-5,15])plt.show()

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

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

x = np.array([1,1,2,3,3,6,6,6,9,9,10,11,12,13,16,18])
y = np.array([18,13,9,6,15,11,6,3,5,2,10,5,6,1,3,1])
label = np.array([1,1,1,1,0,0,0,1,0,1,0,0,0,1,0,1])

fig = plt.figure()
plt.scatter(x, y, c=label, s=60)
plt.show()

Данные на рисунке выше представлены в двумерном плане ядра Гаусса, который не является разделимым. Вы можете попробовать преобразовать эти данные в трехмерное, значит, вы создаете фигуру с 3-мя осями.

В нашем примере ядра Гаусса мы применим полиномиальное отображение, чтобы привести наши данные к трехмерному измерению. Формула преобразования данных выглядит следующим образом.

Вы определяете функцию в Gaussian Kernel Python для создания новых карт объектов.

Вы можете использовать numpy

 для кодирования приведенной выше формулы:

Формула	Эквивалентный код Numpy
Икс	х[:,0]**
у	х[:,1]
х 2	х[:,0]**2
	np.sqrt(2)*
ху	х[:,0]*х[:,1]
у 2	х[:,1]**2

### illustration purpose
def mapping(x, y):    
	x = np.c_[(x, y)]				
    if len(x) >	2:        
    	x_1 = x[:,0]**2        
        x_2 = np.sqrt(2)*x[:,0]*x[:,1]        
        x_3 = x[:,1]**2								
    else:            
    	x_1 = x[0]**2        
        x_2 = np.sqrt(2)*x[0]*x[1]        
        x_3 = x[1]**2			    
   trans_x = np.array([x_1, x_2, x_3])				
   return trans_x			


Новое отображение должно быть трехмерным с 16 точками.

x_1  = mapping(x, y)
x_1.shape

(3, 16)

Давайте создадим новый график с 3 осями, x, y и z соответственно.

# plot
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x_1[0], x_1[1], x_1[2], c=label, s=60)
ax.view_init(30, 185)ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')
plt.show()

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

# plot
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x_1[0], x_1[1], x_1[1], c=label, s=60)
ax.view_init(0, -180)ax.set_ylim([150,-50])
ax.set_zlim([-10000,10000])
ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')plt.show()

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

Самый распространенный способ решить эту проблему — использовать ядро .

Что такое ядро ​​в машинном обучении?

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

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

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

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

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

Давайте посмотрим на пример, чтобы понять концепцию машинного обучения ядра. У вас есть два вектора, x1 и x2. Цель состоит в том, чтобы создать более высокое измерение с помощью полиномиального отображения. Выход равен точечному произведению новой карты признаков. Из приведенного выше метода вам необходимо:

1. Преобразуйте x1 и x2 в новое измерение
2. Вычисление скалярного произведения: общее для всех ядер
3. Преобразуйте x1 и x2 в новое измерение

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

## Kernel
x1 = np.array([3,6])
x2 = np.array([10,10])			

x_1 = mapping(x1, x2)
print(x_1)

Выход

[[ 9. 100. ]
      [ 25.45584412 141.42135624]
      [ 36. 100. ]]

Вычислить скалярное произведение

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

print(np.dot(x_1[:,0], x_1[:,1]))			
8100.0

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

Вместо этого вы можете использовать полиномиальное ядро ​​для вычисления скалярного произведения без преобразования вектора. Эта функция вычисляет скалярное произведение x1 и x2, как если бы эти два вектора были преобразованы в более высокое измерение. Другими словами, функция ядра вычисляет результаты скалярного произведения из другого пространства признаков.

Вы можете написать функцию полиномиального ядра на Python следующим образом.

def polynomial_kernel(x, y, p=2):				
	return (np.dot(x, y)) ** p

Это мощность скалярного произведения двух векторов. Ниже вы возвращаете вторую степень ядра полинома. Результат равен другому методу. Это магия ядра.

polynomial_kernel(x1, x2, p=2)			
8100

Типы методов ядра

Существует множество различных методов ядра. Самым простым является линейное ядро. Эта функция очень хорошо работает для классификации текста. Другое ядро:

• Полиномиальное ядро
• Гауссово ядро

В примере с TensorFlow мы будем использовать случайный Фурье. TensorFlow имеет встроенный оценщик для вычисления нового пространства признаков. Функция фильтра Гаусса является аппроксимацией функции ядра Гаусса.

Функция фильтрации Гаусса вычисляет сходство между точками данных в пространстве гораздо большего размера.

Обучите классификатор Gaussian Kernel с помощью TensorFlow

Цель алгоритма состоит в том, чтобы классифицировать домохозяйство с доходом более или менее 50 тыс.

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

Перед обучением и оценкой модели вы будете действовать следующим образом:

• Шаг 1) Импортируйте библиотеки
• Шаг 2) Импорт данных
• Шаг 3) Подготовьте данные
• Шаг 4) Создайте input_fn
• Шаг 5) Построить логистическую модель: Базовая модель
• Шаг 6) Оцените модель
• Шаг 7) Создайте классификатор ядра
• Шаг 8) Оцените классификатор ядра

Шаг 1) Импортируйте библиотеки

Чтобы импортировать и обучать модели ядра в искусственном интеллекте, вам необходимо импортировать tensorflow, pandas и numpy .

#import numpy as np
from sklearn.model_selection 
import train_test_split
import tensorflow as tf
import pandas as pd
import numpy as np

Шаг 2) Импорт данных

Вы загружаете данные со следующего веб- сайта и импортируете их как кадр данных panda.

## Define path data
COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'label']
PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
PATH_test ="https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test
"## Import 			
df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False)
df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)


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

label = {'<=50K': 0,'>50K': 1}
df_train.label = [label[item] for item in df_train.label]
label_t = {'<=50K.': 0,'>50K.': 1}
df_test.label = [label_t[item] for item in df_test.label]			
df_train.shape			

(32561, 15)			

Шаг 3) Подготовьте данные

Набор данных содержит как непрерывные, так и категориальные признаки. Хорошей практикой является стандартизация значений непрерывных переменных. Вы можете использовать функцию StandardScaler из научного набора. Вы также создаете определяемую пользователем функцию, чтобы упростить преобразование набора поездов и тестов. Обратите внимание, что вы объединяете непрерывные и категориальные переменные в общий набор данных, и массив должен иметь тип: float32

COLUMNS_INT = ['age','fnlwgt','education_num','capital_gain', 'capital_loss', 'hours_week']
CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']
from sklearn.preprocessing import StandardScaler
from sklearn import preprocessing			

def prep_data_str(df):			    
	scaler = StandardScaler()    
    le = preprocessing.LabelEncoder()       
    df_toscale = df[COLUMNS_INT]    
    df_scaled = scaler.fit_transform(df_toscale.astype(np.float64))    
    X_1 = df[CATE_FEATURES].apply(le.fit_transform)    
    y = df['label'].astype(np.int32)    
    X_conc = np.c_[df_scaled, X_1].astype(np.float32)				
    return X_conc, y


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

X_train, y_train = prep_data_str(df_train)
X_test, y_test = prep_data_str(df_test)
print(X_train.shape)			
(32561, 14)

На следующем этапе вы будете обучать логистическую регрессию. Это даст вам базовую точность. Цель состоит в том, чтобы превзойти базовый уровень с помощью другого алгоритма, а именно классификатора ядра.

Шаг 4) Построить логистическую модель: Базовая модель

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

feat_column = tf.contrib.layers.real_valued_column('features', dimension=14)


Оценщик определяется с помощью TensorFlow Estimator, вы указываете столбцы функций и место сохранения графика.

estimator = tf.estimator.LinearClassifier(feature_columns=[feat_column],
                                          n_classes=2,
                                          model_dir = "kernel_log"
                                         )	

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'kernel_log', '_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 0x1a2003f780>, '_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}

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

# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(    
	x={"features": X_train},    
    y=y_train,    
    batch_size=200,    
    num_epochs=None,    
    shuffle=True)


Вы можете обучить модель с итерацией 1.000

estimator.train(input_fn=train_input_fn, 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 kernel_log/model.ckpt.
INFO:tensorflow:loss = 138.62949, step = 1
INFO:tensorflow:global_step/sec: 324.16
INFO:tensorflow:loss = 87.16762, step = 101 (0.310 sec)
INFO:tensorflow:global_step/sec: 267.092
INFO:tensorflow:loss = 71.53657, step = 201 (0.376 sec)
INFO:tensorflow:global_step/sec: 292.679
INFO:tensorflow:loss = 69.56703, step = 301 (0.340 sec)
INFO:tensorflow:global_step/sec: 225.582
INFO:tensorflow:loss = 74.615875, step = 401 (0.445 sec)
INFO:tensorflow:global_step/sec: 209.975
INFO:tensorflow:loss = 76.49044, step = 501 (0.475 sec)
INFO:tensorflow:global_step/sec: 241.648
INFO:tensorflow:loss = 66.38373, step = 601 (0.419 sec)
INFO:tensorflow:global_step/sec: 305.193
INFO:tensorflow:loss = 87.93341, step = 701 (0.327 sec)
INFO:tensorflow:global_step/sec: 396.295
INFO:tensorflow:loss = 76.61518, step = 801 (0.249 sec)
INFO:tensorflow:global_step/sec: 359.857
INFO:tensorflow:loss = 78.54885, step = 901 (0.277 sec)
INFO:tensorflow:Saving checkpoints for 1000 into kernel_log/model.ckpt.
INFO:tensorflow:Loss for final step: 67.79706.


<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1a1fa3cbe0>

Шаг 6) Оцените модель

Вы определяете оценщик numpy для оценки модели. Вы используете весь набор данных для оценки

# Evaluation
test_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"features": X_test},
    y=y_test,
    batch_size=16281,
    num_epochs=1,
    shuffle=False)
estimator.evaluate(input_fn=test_input_fn, steps=1)

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-07-12-15:58:22
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from kernel_log/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/1]
INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:23
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.82353663, accuracy_baseline = 0.76377374, auc = 0.84898686, auc_precision_recall = 0.67214864, average_loss = 0.3877216, global_step = 1000, label/mean = 0.23622628, loss = 6312.495, precision = 0.7362797, prediction/mean = 0.21208474, recall = 0.39417577

{'accuracy': 0.82353663,
 'accuracy_baseline': 0.76377374,
 'auc': 0.84898686,
 'auc_precision_recall': 0.67214864,
 'average_loss': 0.3877216,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 6312.495,
 'precision': 0.7362797,
 'prediction/mean': 0.21208474,
 'recall': 0.39417577}

У вас точность 82 процента. В следующем разделе вы попытаетесь превзойти логистический классификатор с помощью классификатора ядра.

Шаг 7) Создайте классификатор ядра

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

Вам нужны два предопределенных оценщика, доступных в TensorFlow, для обучения классификатора ядра:

• RandomFourierFeatureMapper
• ЯдроЛинейныйКлассификатор

В первом разделе вы узнали, что вам нужно преобразовать низкое измерение в высокое, используя функцию ядра. Точнее, вы будете использовать случайный Фурье, который является аппроксимацией функции Гаусса. К счастью, в библиотеке Tensorflow есть функция RandomFourierFeatureMapper. Модель можно обучить с помощью оценщика KernelLinearClassifier.

Чтобы построить модель, выполните следующие действия:

1. Установите функцию ядра высокой размерности
2. Установите гиперпараметр L2
3. Построить модель
4. Обучите модель
5. Оценить модель

Шаг A) Установите функцию ядра высокой размерности

Текущий набор данных содержит 14 объектов, которые вы преобразуете в новое высокое измерение 5000-мерного вектора. Вы используете случайные функции Фурье для достижения преобразования. Если вы помните формулу ядра Гаусса, вы заметите, что есть параметр стандартного отклонения, который необходимо определить. Этот параметр управляет мерой сходства, используемой во время классификации.

Вы можете настроить все параметры в RandomFourierFeatureMapper с помощью:

• input_dim = 14
• output_dim = 5000
• стандартное отклонение = 4

### Prep Kernel
kernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')


Вам нужно построить картограф ядра, используя столбцы функций, созданные ранее: feat_column

### Map Kernel
kernel_mappers = {feat_column: [kernel_mapper]}

Шаг B) Установите гиперпараметр L2

Чтобы предотвратить переоснащение, вы наказываете функцию потерь с помощью регуляризатора L2. Вы устанавливаете гиперпараметр L2 на 0,1 и скорость обучения на 5

optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)

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

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

### Prep estimator
estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier(
    n_classes=2,
    optimizer=optimizer,
    kernel_mappers=kernel_mappers, 
    model_dir="kernel_train")

WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/kernel_methods/python/kernel_estimators.py:305: multi_class_head (from tensorflow.contrib.learn.python.learn.estimators.head) is deprecated and will be removed in a future version.
Instructions for updating:
Please switch to tf.contrib.estimator.*_head.
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:1179: BaseEstimator.__init__ (from tensorflow.contrib.learn.python.learn.estimators.estimator) is deprecated and will be removed in a future version.
Instructions for updating:
Please replace uses of any Estimator from tf.contrib.learn with an Estimator from tf.estimator.*
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/estimator.py:427: RunConfig.__init__ (from tensorflow.contrib.learn.python.learn.estimators.run_config) is deprecated and will be removed in a future version.
Instructions for updating:
When switching to tf.estimator.Estimator, use tf.estimator.RunConfig instead.
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_task_type': None, '_task_id': 0, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a200ae550>, '_master': '', '_num_ps_replicas': 0, '_num_worker_replicas': 0, '_environment': 'local', '_is_chief': True, '_evaluation_master': '', '_train_distribute': None, '_tf_config': gpu_options {
  per_process_gpu_memory_fraction: 1.0
}
, '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_secs': 600, '_log_step_count_steps': 100, '_session_config': None, '_save_checkpoints_steps': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_model_dir': 'kernel_train'}

Шаг D) Обучите модель

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

### estimate 
estimator_kernel.fit(input_fn=train_input_fn, steps=2000)

WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:From /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/estimators/head.py:678: ModelFnOps.__new__ (from tensorflow.contrib.learn.python.learn.estimators.model_fn) is deprecated and will be removed in a future version.
Instructions for updating:
When switching to tf.estimator.Estimator, use tf.estimator.EstimatorSpec. You can use the `estimator_spec` method to create an equivalent one.
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 kernel_train/model.ckpt.
INFO:tensorflow:loss = 0.6931474, step = 1
INFO:tensorflow:global_step/sec: 86.6365
INFO:tensorflow:loss = 0.39374447, step = 101 (1.155 sec)
INFO:tensorflow:global_step/sec: 80.1986
INFO:tensorflow:loss = 0.3797774, step = 201 (1.247 sec)
INFO:tensorflow:global_step/sec: 79.6376
INFO:tensorflow:loss = 0.3908726, step = 301 (1.256 sec)
INFO:tensorflow:global_step/sec: 95.8442
INFO:tensorflow:loss = 0.41890752, step = 401 (1.043 sec)
INFO:tensorflow:global_step/sec: 93.7799
INFO:tensorflow:loss = 0.35700393, step = 501 (1.066 sec)
INFO:tensorflow:global_step/sec: 94.7071
INFO:tensorflow:loss = 0.35535482, step = 601 (1.056 sec)
INFO:tensorflow:global_step/sec: 90.7402
INFO:tensorflow:loss = 0.3692882, step = 701 (1.102 sec)
INFO:tensorflow:global_step/sec: 94.4924
INFO:tensorflow:loss = 0.34746957, step = 801 (1.058 sec)
INFO:tensorflow:global_step/sec: 95.3472
INFO:tensorflow:loss = 0.33655524, step = 901 (1.049 sec)
INFO:tensorflow:global_step/sec: 97.2928
INFO:tensorflow:loss = 0.35966292, step = 1001 (1.028 sec)
INFO:tensorflow:global_step/sec: 85.6761
INFO:tensorflow:loss = 0.31254214, step = 1101 (1.167 sec)
INFO:tensorflow:global_step/sec: 91.4194
INFO:tensorflow:loss = 0.33247527, step = 1201 (1.094 sec)
INFO:tensorflow:global_step/sec: 82.5954
INFO:tensorflow:loss = 0.29305756, step = 1301 (1.211 sec)
INFO:tensorflow:global_step/sec: 89.8748
INFO:tensorflow:loss = 0.37943482, step = 1401 (1.113 sec)
INFO:tensorflow:global_step/sec: 76.9761
INFO:tensorflow:loss = 0.34204718, step = 1501 (1.300 sec)
INFO:tensorflow:global_step/sec: 73.7192
INFO:tensorflow:loss = 0.34614792, step = 1601 (1.356 sec)
INFO:tensorflow:global_step/sec: 83.0573
INFO:tensorflow:loss = 0.38911164, step = 1701 (1.204 sec)
INFO:tensorflow:global_step/sec: 71.7029
INFO:tensorflow:loss = 0.35255936, step = 1801 (1.394 sec)
INFO:tensorflow:global_step/sec: 73.2663
INFO:tensorflow:loss = 0.31130585, step = 1901 (1.365 sec)
INFO:tensorflow:Saving checkpoints for 2000 into kernel_train/model.ckpt.
INFO:tensorflow:Loss for final step: 0.37795097.

KernelLinearClassifier(params={'head': <tensorflow.contrib.learn.python.learn.estimators.head._BinaryLogisticHead object at 0x1a2054cd30>, 'feature_columns': {_RealValuedColumn(column_name='features_MAPPED', dimension=5000, default_value=None, dtype=tf.float32, normalizer=None)}, 'optimizer': <tensorflow.python.training.ftrl.FtrlOptimizer object at 0x1a200aec18>, 'kernel_mappers': {_RealValuedColumn(column_name='features', dimension=14, default_value=None, dtype=tf.float32, normalizer=None): [<tensorflow.contrib.kernel_methods.python.mappers.random_fourier_features.RandomFourierFeatureMapper object at 0x1a200ae400>]}})

Шаг E) Оцените модель

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

# Evaluate and report metrics.
eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)

WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool.
WARNING:tensorflow:Casting <dtype: 'int32'> labels to bool.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Starting evaluation at 2018-07-12-15:58:50
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from kernel_train/model.ckpt-2000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/1]
INFO:tensorflow:Finished evaluation at 2018-07-12-15:58:51
INFO:tensorflow:Saving dict for global step 2000: accuracy = 0.83975184, accuracy/baseline_label_mean = 0.23622628, accuracy/threshold_0.500000_mean = 0.83975184, auc = 0.8904007, auc_precision_recall = 0.72722375, global_step = 2000, labels/actual_label_mean = 0.23622628, labels/prediction_mean = 0.23786618, loss = 0.34277728, precision/positive_threshold_0.500000_mean = 0.73001117, recall/positive_threshold_0.500000_mean = 0.5104004

Окончательная точность составляет 84%, что на 2% больше по сравнению с логистической регрессией. Существует компромисс между повышением точности и вычислительными затратами. Вам нужно подумать, стоит ли улучшение на 2% времени, потраченного на другой классификатор, и оказывает ли оно убедительное влияние на ваш бизнес.

Резюме

Ядро — отличный инструмент для преобразования нелинейных данных в (почти) линейные. Недостатком этого метода является его трудоемкость и дороговизна.

Ниже вы можете найти наиболее важный код для обучения классификатора ядра.

Установите функцию ядра высокой размерности

• input_dim = 14
• output_dim = 5000
• стандартное отклонение = 4

### Prep Kernelkernel_mapper = tf.contrib.kernel_methods.RandomFourierFeatureMapper(input_dim=14, output_dim=5000, stddev=4, name='rffm')

Установите гиперпараметр L2

optimizer = tf.train.FtrlOptimizer(learning_rate=5, l2_regularization_strength=0.1)

Построить модель

estimator_kernel = tf.contrib.kernel_methods.KernelLinearClassifier(    n_classes=2,    
	optimizer=optimizer,    
    kernel_mappers=kernel_mappers,    
    model_dir="kernel_train")


Обучите модель

estimator_kernel.fit(input_fn=train_input_fn, steps=2000)

Оценить модель

eval_metrics = estimator_kernel.evaluate(input_fn=test_input_fn, steps=1)

Статья является переводом guru99-com.

Scikit-learn имеет лучшую документацию среди всех библиотек с открытым исходным кодом. Он предоставляет интерактивную диаграмму по адресу https://scikit-learn.org/stable/tutorial/machine_learning_map/index.html .

Scikit-learn не очень сложен в использовании и дает отличные результаты. Однако scikitlearn не поддерживает параллельные вычисления. С ним можно запустить алгоритм глубокого обучения, но это не оптимальное решение, особенно если вы знаете, как использовать TensorFlow.

Как скачать и установить Scikit-learn

Теперь в этом руководстве по Python Scikit-learn мы узнаем, как загрузить и установить Scikit-learn:

Вариант 1: АМС

scikit-learn можно использовать через AWS. Пожалуйста , обратитесь к образу докера с предустановленным scikit-learn.

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

import sys
!{sys.executable} -m pip install git+git://github.com/scikit-learn/scikit-learn.git

Вариант 2: Mac или Windows с использованием Anaconda

Чтобы узнать об установке Anaconda, перейдите по ссылке https://www.guru99.com/download-install-tensorflow.html.

Недавно разработчики scikit выпустили версию для разработчиков, которая решает общую проблему, с которой сталкивается текущая версия. Мы сочли более удобным использовать версию для разработчиков вместо текущей версии.

Как установить scikit-learn с помощью среды Conda

Если вы установили scikit-learn со средой conda, выполните шаг для обновления до версии 0.20.

Шаг 1) Активируйте среду тензорного потока

source activate hello-tf

Шаг 2) Удалите scikit lean с помощью команды conda.

conda remove scikit-learn

Шаг 3) Установите версию для разработчиков.
Установите версию для разработчиков scikit Learn вместе с необходимыми библиотеками.

conda install -c anaconda git
pip install Cython
pip install h5py
pip install git+git://github.com/scikit-learn/scikit-learn.git

ПРИМЕЧАНИЕ. Пользователю Windows необходимо установить Microsoft Visual C++ 14. Вы можете скачать его здесь .

Пример Scikit-Learn с машинным обучением

Этот учебник Scikit разделен на две части:

1. Машинное обучение с scikit-learn
2. Как доверить свою модель с помощью LIME

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

Шаг 1) Импорт данных

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

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

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

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

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

## List Categorical
CATE_FEATURES = df_train.iloc[:,:-1].select_dtypes('object').columns
print(CATE_FEATURES)

## List continuous
CONTI_FEATURES =  df_train._get_numeric_data()
print(CONTI_FEATURES)

Вот код для импорта данных:

# Import dataset
import pandas as pd

## Define path data
COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital',
           'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss',
           'hours_week', 'native_country', 'label']
### Define continuous list
CONTI_FEATURES  = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']
### Define categorical list
CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']

## Prepare the data
features = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital',
           'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss',
           'hours_week', 'native_country']

PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"

df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False)
df_train[CONTI_FEATURES] =df_train[CONTI_FEATURES].astype('float64')

Вы можете проверить количество уникальных значений функций native_country. Вы можете видеть, что только одно домашнее хозяйство происходит из Голландии-Нидерландов. Это домашнее хозяйство не принесет нам никакой информации, но принесет ошибку во время обучения.

df_train.native_country.value_counts()

United-States                 29170
Mexico                          643
?                               583
Philippines                     198
Germany                         137
Canada                          121
Puerto-Rico                     114
El-Salvador                     106
India                           100
Cuba                             95
England                          90
Jamaica                          81
South                            80
China                            75
Italy                            73
Dominican-Republic               70
Vietnam                          67
Guatemala                        64
Japan                            62
Poland                           60
Columbia                         59
Taiwan                           51
Haiti                            44
Iran                             43
Portugal                         37
Nicaragua                        34
Peru                             31
France                           29
Greece                           29
Ecuador                          28
Ireland                          24
Hong                             20
Cambodia                         19
Trinadad&Tobago                  19
Thailand                         18
Laos                             18
Yugoslavia                       16
Outlying-US(Guam-USVI-etc)       14
Honduras                         13
Hungary                          13
Scotland                         12
Holand-Netherlands                1
Name: native_country, dtype: int64



Вы можете исключить эту неинформативную строку из набора данных.

## Drop Netherland, because only one row
df_train = df_train[df_train.native_country != "Holand-Netherlands"]

Затем вы сохраняете положение непрерывных объектов в списке. Он понадобится вам на следующем шаге для создания конвейера.

Приведенный ниже код будет перебирать все имена столбцов в CONTI_FEATURES и получать их местоположение (т. е. номер), а затем добавлять их в список с именем conti_features.

## Get the column index of the categorical features
conti_features = []
for i in CONTI_FEATURES:
    position = df_train.columns.get_loc(i)
    conti_features.append(position)
print(conti_features)  

[0, 2, 10, 4, 11, 12]


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

## Get the column index of the categorical features
categorical_features = []
for i in CATE_FEATURES:
    position = df_train.columns.get_loc(i)
    categorical_features.append(position)
print(categorical_features)  

[1, 3, 5, 6, 7, 8, 9, 13]

df_train.head(5)

print(df_train[CATE_FEATURES].nunique(),
      'There are',sum(df_train[CATE_FEATURES].nunique()), 'groups in the whole dataset')

workclass          9
education         16
marital            7
occupation        15
relationship       6
race               5
sex                2
native_country    41
dtype: int64 There are 101 groups in the whole dataset

print(df_train[CATE_FEATURES].nunique(),
      'There are',sum(df_train[CATE_FEATURES].nunique()), 'groups in the whole dataset')

workclass          9
education         16
marital            7
occupation        15
relationship       6
race               5
sex                2
native_country    41
dtype: int64 There are 101 groups in the whole dataset

for i in CATE_FEATURES:
    print(df_train[i].unique())

['State-gov' 'Self-emp-not-inc' 'Private' 'Federal-gov' 'Local-gov' '?'
 'Self-emp-inc' 'Without-pay' 'Never-worked']
['Bachelors' 'HS-grad' '11th' 'Masters' '9th' 'Some-college' 'Assoc-acdm'
 'Assoc-voc' '7th-8th' 'Doctorate' 'Prof-school' '5th-6th' '10th'
 '1st-4th' 'Preschool' '12th']
['Never-married' 'Married-civ-spouse' 'Divorced' 'Married-spouse-absent'
 'Separated' 'Married-AF-spouse' 'Widowed']
['Adm-clerical' 'Exec-managerial' 'Handlers-cleaners' 'Prof-specialty'
 'Other-service' 'Sales' 'Craft-repair' 'Transport-moving'
 'Farming-fishing' 'Machine-op-inspct' 'Tech-support' '?'
 'Protective-serv' 'Armed-Forces' 'Priv-house-serv']
['Not-in-family' 'Husband' 'Wife' 'Own-child' 'Unmarried' 'Other-relative']
['White' 'Black' 'Asian-Pac-Islander' 'Amer-Indian-Eskimo' 'Other']
['Male' 'Female']
['United-States' 'Cuba' 'Jamaica' 'India' '?' 'Mexico' 'South'
 'Puerto-Rico' 'Honduras' 'England' 'Canada' 'Germany' 'Iran'
 'Philippines' 'Italy' 'Poland' 'Columbia' 'Cambodia' 'Thailand' 'Ecuador'
 'Laos' 'Taiwan' 'Haiti' 'Portugal' 'Dominican-Republic' 'El-Salvador'
 'France' 'Guatemala' 'China' 'Japan' 'Yugoslavia' 'Peru'
 'Outlying-US(Guam-USVI-etc)' 'Scotland' 'Trinadad&Tobago' 'Greece'
 'Nicaragua' 'Vietnam' 'Hong' 'Ireland' 'Hungary']

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(df_train[features],
                                                    df_train.label,
                                                    test_size = 0.2,
                                                    random_state=0)
X_train.head(5)
print(X_train.shape, X_test.shape)

(26048, 14) (6512, 14)

Шаг 3) Создайте конвейер

Конвейер упрощает подачу в модель непротиворечивых данных.

Идея заключается в том, чтобы поместить необработанные данные в «конвейер» для выполнения операций.

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

У вас есть выбор; жестко закодируйте два процесса или создайте конвейер. Первый выбор может привести к утечке данных и со временем привести к несоответствиям. Лучшим вариантом является использование конвейера.

from sklearn.preprocessing import StandardScaler, OneHotEncoder, LabelEncoder
from sklearn.compose import ColumnTransformer, make_column_transformer
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression

Конвейер выполнит две операции перед подачей на логистический классификатор:

1. Стандартизируйте переменную: `StandardScaler()“.
2. Преобразование категориальных функций: OneHotEncoder(sparse=False)

Вы можете выполнить два шага, используя файл make_column_transformer. Эта функция недоступна в текущей версии scikit-learn (0.19). В текущей версии невозможно выполнить кодировщик меток и один горячий кодировщик в конвейере. Это одна из причин, по которой мы решили использовать версию для разработчиков.

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

• conti_features, StandardScaler() внутри make_column_transformer.
  • conti_features: список с непрерывной переменной
  • StandardScaler: стандартизируйте переменную

Объект OneHotEncoder внутри make_column_transformer автоматически кодирует метку.

preprocess = make_column_transformer(
    (conti_features, StandardScaler()),
    ### Need to be numeric not string to specify columns name 
    (categorical_features, OneHotEncoder(sparse=False))
)

Вы можете проверить, работает ли конвейер с помощью fit_transform. Набор данных должен иметь следующий вид: 26048, 107.

preprocess.fit_transform(X_train).shape

(26048, 107)

Преобразователь данных готов к использованию. Вы можете создать конвейер с помощью make_pipeline. Как только данные преобразованы, вы можете заполнить логистическую регрессию.

model = make_pipeline(
    preprocess,
    LogisticRegression())


Обучение модели с помощью scikit-learn тривиально. Вам нужно использовать подгонку объекта, которому предшествует конвейер, т.е. модель. Вы можете распечатать точность с помощью объекта score из библиотеки scikit-learn.

model.fit(X_train, y_train)
print("logistic regression score: %f" % model.score(X_test, y_test))

logistic regression score: 0.850891


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

model.predict_proba(X_test)

array([[0.83576663, 0.16423337],
       [0.94582765, 0.05417235],
       [0.64760587, 0.35239413],
       ...,
       [0.99639252, 0.00360748],
       [0.02072181, 0.97927819],
       [0.56781353, 0.43218647]])

from sklearn.model_selection import GridSearchCV
# Construct the parameter grid
param_grid = {
    'logisticregression__C': [0.001, 0.01,0.1, 1.0],
    }

Вы можете обучить модель с помощью GridSearchCV с параметрами gri и cv.

# Train the model
grid_clf = GridSearchCV(model,
                        param_grid,
                        cv=10,
                        iid=False)
grid_clf.fit(X_train, y_train)

GridSearchCV(cv=10, error_score='raise-deprecating',
       estimator=Pipeline(memory=None,
     steps=[('columntransformer', ColumnTransformer(n_jobs=1, remainder='drop', transformer_weights=None,
         transformers=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True), [0, 2, 10, 4, 11, 12]), ('onehotencoder', OneHotEncoder(categorical_features=None, categories=None,...ty='l2', random_state=None, solver='liblinear', tol=0.0001,
          verbose=0, warm_start=False))]),
       fit_params=None, iid=False, n_jobs=1,
       param_grid={'logisticregression__C': [0.001, 0.01, 0.1, 1.0]},
       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',
       scoring=None, verbose=0)

grid_clf.best_params_

ВЫХОД

{'logisticregression__C': 1.0}


После обучения модели с четырьмя различными значениями регуляризации оптимальный параметр равен

print("best logistic regression from grid search: %f" % grid_clf.best_estimator_.score(X_test, y_test))

grid_clf.best_estimator_.predict_proba(X_test)

array([[0.83576677, 0.16423323],
       [0.9458291 , 0.0541709 ],
       [0.64760416, 0.35239584],
       ...,
       [0.99639224, 0.00360776],
       [0.02072033, 0.97927967],
       [0.56782222, 0.43217778]])

use import sys
!{sys.executable} -m pip install xgboost

import xgboost
from sklearn.model_selection import RandomizedSearchCV
from sklearn.model_selection import StratifiedKFold

Следующий шаг в этом руководстве по Scikit Python включает указание параметров для настройки. Вы можете обратиться к официальной документации, чтобы увидеть все параметры для настройки. Для руководства по Python Sklearn вы выбираете только два гиперпараметра с двумя значениями в каждом. XGBoost требует много времени для обучения, чем больше гиперпараметров в сетке, тем дольше нужно ждать.

params = {
        'xgbclassifier__gamma': [0.5, 1],
        'xgbclassifier__max_depth': [3, 4]
        }

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

model_xgb = make_pipeline(
    preprocess,
    xgboost.XGBClassifier(
                          n_estimators=600,
                          objective='binary:logistic',
                          silent=True,
                          nthread=1)
)

skf = StratifiedKFold(n_splits=3,
                      shuffle = True,
                      random_state = 1001)

random_search = RandomizedSearchCV(model_xgb,
                                   param_distributions=params,
                                   n_iter=4,
                                   scoring='accuracy',
                                   n_jobs=4,
                                   cv=skf.split(X_train, y_train),
                                   verbose=3,
                                   random_state=1001)

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

#grid_xgb = GridSearchCV(model_xgb, params, cv=10, iid=False)
random_search.fit(X_train, y_train)

Fitting 3 folds for each of 4 candidates, totalling 12 fits
[CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5 ............
[CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5 ............
[CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5 ............
[CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5 ............
[CV]  xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5, score=0.8759645283888057, total= 1.0min
[CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5 ............
[CV]  xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5, score=0.8729701715996775, total= 1.0min
[CV]  xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5, score=0.8706519235199263, total= 1.0min
[CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5 ............
[CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1 ..............
[CV]  xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5, score=0.8735460094437406, total= 1.3min
[CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1 ..............
[CV]  xgbclassifier__max_depth=3, xgbclassifier__gamma=1, score=0.8722791661868018, total=  57.7s
[CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1 ..............
[CV]  xgbclassifier__max_depth=3, xgbclassifier__gamma=1, score=0.8753886905447426, total= 1.0min
[CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1 ..............
[CV]  xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5, score=0.8697304768486523, total= 1.3min
[CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1 ..............
[CV]  xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5, score=0.8740066797189912, total= 1.4min
[CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1 ..............
[CV]  xgbclassifier__max_depth=3, xgbclassifier__gamma=1, score=0.8707671043538355, total= 1.0min
[CV]  xgbclassifier__max_depth=4, xgbclassifier__gamma=1, score=0.8729701715996775, total= 1.2min
[Parallel(n_jobs=4)]: Done  10 out of  12 | elapsed:  3.6min remaining:   43.5s
[CV]  xgbclassifier__max_depth=4, xgbclassifier__gamma=1, score=0.8736611770125533, total= 1.2min
[CV]  xgbclassifier__max_depth=4, xgbclassifier__gamma=1, score=0.8692697535130154, total= 1.2min

[Parallel(n_jobs=4)]: Done  12 out of  12 | elapsed:  3.6min finished
/Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/sklearn/model_selection/_search.py:737: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal. DeprecationWarning)

RandomizedSearchCV(cv=<generator object _BaseKFold.split at 0x1101eb830>,
          error_score='raise-deprecating',
          estimator=Pipeline(memory=None,
     steps=[('columntransformer', ColumnTransformer(n_jobs=1, remainder='drop', transformer_weights=None,
         transformers=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True), [0, 2, 10, 4, 11, 12]), ('onehotencoder', OneHotEncoder(categorical_features=None, categories=None,...
       reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
       silent=True, subsample=1))]),
          fit_params=None, iid='warn', n_iter=4, n_jobs=4,
          param_distributions={'xgbclassifier__gamma': [0.5, 1], 'xgbclassifier__max_depth': [3, 4]},
          pre_dispatch='2*n_jobs', random_state=1001, refit=True,
          return_train_score='warn', scoring='accuracy', verbose=3)

Как видите, XGBoost имеет лучший результат, чем предыдущая логистическая регрессия.

print("Best parameter", random_search.best_params_)
print("best logistic regression from grid search: %f" % random_search.best_estimator_.score(X_test, y_test))

Best parameter {'xgbclassifier__max_depth': 3, 'xgbclassifier__gamma': 0.5}
best logistic regression from grid search: 0.873157

random_search.best_estimator_.predict(X_test)

array(['<=50K', '<=50K', '<=50K', ..., '<=50K', '>50K', '<=50K'],      dtype=object)

Создайте DNN с помощью MLPClassifier в scikit-learn

Наконец, вы можете обучить алгоритм глубокого обучения с помощью scikit-learn. Метод такой же, как и у другого классификатора. Классификатор доступен на MLPClassifier.

from sklearn.neural_network import MLPClassifier

Вы определяете следующий алгоритм глубокого обучения:

• Адам Солвер
• Функция активации Relu
• Альфа = 0,0001
• размер партии 150
• Два скрытых слоя по 100 и 50 нейронов соответственно.

model_dnn = make_pipeline(
    preprocess,
    MLPClassifier(solver='adam',
                  alpha=0.0001,
                  activation='relu',
                    batch_size=150,
                    hidden_layer_sizes=(200, 100),
                    random_state=1))

Вы можете изменить количество слоев, чтобы улучшить модель

model_dnn.fit(X_train, y_train)
  print("DNN regression score: %f" % model_dnn.score(X_test, y_test))

LIME: доверяйте своей модели

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

Три исследователя придумали отличный инструмент, чтобы увидеть, как компьютер делает прогноз. Статья называется «Почему я должен вам доверять?».

Они разработали алгоритм под названием Local Interpretable Model-Agnostic Explanations (LIME) .

Возьмите пример:

иногда вы не знаете, можно ли доверять прогнозу машинного обучения:

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

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

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

Lime может подсказать, какие функции влияют на решения классификатора.

Подготовка данных

Это пара вещей, которые вам нужно изменить, чтобы запустить LIME с python . В первую очередь нужно установить лайм в терминал. Вы можете использовать pip install лайм

Lime использует объект LimeTabularExplainer для локальной аппроксимации модели. Этот объект требует:

• набор данных в формате numpy
• Название функций: feature_names
• Название классов: class_names
• Индекс столбца категориальных признаков: categorical_features
• Имя группы для каждой категориальной функции: categorical_names

Создать набор поездов numpy

Вы можете очень легко скопировать и преобразовать df_train из pandas в numpy.

df_train.head(5)
# Create numpy data
df_lime = df_train
df_lime.head(3)

Получить имя класса Метка доступна с помощью объекта unique(). Тебе следует увидеть:

• ‘<=50K’
• ‘> 50 тыс.’

# Get the class name
class_names = df_lime.label.unique()
class_names

array(['<=50K', '>50K'], dtype=object)

индекс столбца категориальных признаков

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

## 
import sklearn.preprocessing as preprocessing
categorical_names = {}
for feature in CATE_FEATURES:
    le = preprocessing.LabelEncoder()
    le.fit(df_lime[feature])
    df_lime[feature] = le.transform(df_lime[feature])
    categorical_names[feature] = le.classes_
print(categorical_names)    

{'workclass': array(['?', 'Federal-gov', 'Local-gov', 'Never-worked', 'Private',
       'Self-emp-inc', 'Self-emp-not-inc', 'State-gov', 'Without-pay'],
      dtype=object), 'education': array(['10th', '11th', '12th', '1st-4th', '5th-6th', '7th-8th', '9th',
       'Assoc-acdm', 'Assoc-voc', 'Bachelors', 'Doctorate', 'HS-grad',
       'Masters', 'Preschool', 'Prof-school', 'Some-college'],
      dtype=object), 'marital': array(['Divorced', 'Married-AF-spouse', 'Married-civ-spouse',
       'Married-spouse-absent', 'Never-married', 'Separated', 'Widowed'],
      dtype=object), 'occupation': array(['?', 'Adm-clerical', 'Armed-Forces', 'Craft-repair',
       'Exec-managerial', 'Farming-fishing', 'Handlers-cleaners',
       'Machine-op-inspct', 'Other-service', 'Priv-house-serv',
       'Prof-specialty', 'Protective-serv', 'Sales', 'Tech-support',
       'Transport-moving'], dtype=object), 'relationship': array(['Husband', 'Not-in-family', 'Other-relative', 'Own-child',
       'Unmarried', 'Wife'], dtype=object), 'race': array(['Amer-Indian-Eskimo', 'Asian-Pac-Islander', 'Black', 'Other',
       'White'], dtype=object), 'sex': array(['Female', 'Male'], dtype=object), 'native_country': array(['?', 'Cambodia', 'Canada', 'China', 'Columbia', 'Cuba',
       'Dominican-Republic', 'Ecuador', 'El-Salvador', 'England',
       'France', 'Germany', 'Greece', 'Guatemala', 'Haiti', 'Honduras',
       'Hong', 'Hungary', 'India', 'Iran', 'Ireland', 'Italy', 'Jamaica',
       'Japan', 'Laos', 'Mexico', 'Nicaragua',
       'Outlying-US(Guam-USVI-etc)', 'Peru', 'Philippines', 'Poland',
       'Portugal', 'Puerto-Rico', 'Scotland', 'South', 'Taiwan',
       'Thailand', 'Trinadad&Tobago', 'United-States', 'Vietnam',
       'Yugoslavia'], dtype=object)}

df_lime.dtypes

age               float64
workclass           int64
fnlwgt            float64
education           int64
education_num     float64
marital             int64
occupation          int64
relationship        int64
race                int64
sex                 int64
capital_gain      float64
capital_loss      float64
hours_week        float64
native_country      int64
label              object
dtype: object

Теперь, когда набор данных готов, вы можете создать другой набор данных, как показано в приведенных ниже примерах обучения Scikit. Вы фактически преобразуете данные вне конвейера, чтобы избежать ошибок с LIME. Учебный набор в LimeTabularExplainer должен быть пустым массивом без строки. С помощью описанного выше метода у вас уже есть преобразованный набор обучающих данных.

from sklearn.model_selection import train_test_split
X_train_lime, X_test_lime, y_train_lime, y_test_lime = train_test_split(df_lime[features],
                                                    df_lime.label,
                                                    test_size = 0.2,
                                                    random_state=0)
X_train_lime.head(5)

Можно сделать пайплайн с оптимальными параметрами из XGBoost

model_xgb = make_pipeline(
    preprocess,
    xgboost.XGBClassifier(max_depth = 3,
                          gamma = 0.5,
                          n_estimators=600,
                          objective='binary:logistic',
                          silent=True,
                          nthread=1))

model_xgb.fit(X_train_lime, y_train_lime)

/Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/sklearn/preprocessing/_encoders.py:351: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.
If you want the future behavior and silence this warning, you can specify "categories='auto'."In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.
  warnings.warn(msg, FutureWarning)

Pipeline(memory=None,
     steps=[('columntransformer', ColumnTransformer(n_jobs=1, remainder='drop', transformer_weights=None,
         transformers=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True), [0, 2, 10, 4, 11, 12]), ('onehotencoder', OneHotEncoder(categorical_features=None, categories=None,...
       reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,
       silent=True, subsample=1))])


Вы получаете предупреждение. Предупреждение объясняет, что вам не нужно создавать кодировщик меток перед конвейером. Если вы не хотите использовать LIME, вы можете использовать метод из первой части руководства по машинному обучению с помощью Scikit-learn. В противном случае вы можете продолжить использовать этот метод, сначала создав закодированный набор данных, установите кодировщик в конвейере.

print("best logistic regression from grid search: %f" % model_xgb.score(X_test_lime, y_test_lime))

best logistic regression from grid search: 0.873157

model_xgb.predict_proba(X_test_lime)

array([[7.9646105e-01, 2.0353897e-01],
       [9.5173013e-01, 4.8269872e-02],
       [7.9344827e-01, 2.0655173e-01],
       ...,
       [9.9031430e-01, 9.6856682e-03],
       [6.4581633e-04, 9.9935418e-01],
       [9.7104281e-01, 2.8957171e-02]], dtype=float32)

Прежде чем использовать LIME в действии, давайте создадим массив numpy с признаками неправильной классификации. Вы можете использовать этот список позже, чтобы получить представление о том, что вводит классификатор в заблуждение.

temp = pd.concat([X_test_lime, y_test_lime], axis= 1)
temp['predicted'] = model_xgb.predict(X_test_lime)
temp['wrong']=  temp['label'] != temp['predicted']
temp = temp.query('wrong==True').drop('wrong', axis=1)
temp= temp.sort_values(by=['label'])
temp.shape

(826, 16)

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

predict_fn = lambda x: model_xgb.predict_proba(x).astype(float)
X_test_lime.dtypes

age               float64
workclass           int64
fnlwgt            float64
education           int64
education_num     float64
marital             int64
occupation          int64
relationship        int64
race                int64
sex                 int64
capital_gain      float64
capital_loss      float64
hours_week        float64
native_country      int64
dtype: object

predict_fn(X_test_lime)

array([[7.96461046e-01, 2.03538969e-01],
       [9.51730132e-01, 4.82698716e-02],
       [7.93448269e-01, 2.06551731e-01],
       ...,
       [9.90314305e-01, 9.68566816e-03],
       [6.45816326e-04, 9.99354184e-01],
       [9.71042812e-01, 2.89571714e-02]])

Вы конвертируете кадр данных pandas в массив numpy

X_train_lime = X_train_lime.values
X_test_lime = X_test_lime.values
X_test_lime

array([[4.00000e+01, 5.00000e+00, 1.93524e+05, ..., 0.00000e+00,
        4.00000e+01, 3.80000e+01],
       [2.70000e+01, 4.00000e+00, 2.16481e+05, ..., 0.00000e+00,
        4.00000e+01, 3.80000e+01],
       [2.50000e+01, 4.00000e+00, 2.56263e+05, ..., 0.00000e+00,
        4.00000e+01, 3.80000e+01],
       ...,
       [2.80000e+01, 6.00000e+00, 2.11032e+05, ..., 0.00000e+00,
        4.00000e+01, 2.50000e+01],
       [4.40000e+01, 4.00000e+00, 1.67005e+05, ..., 0.00000e+00,
        6.00000e+01, 3.80000e+01],
       [5.30000e+01, 4.00000e+00, 2.57940e+05, ..., 0.00000e+00,
        4.00000e+01, 3.80000e+01]])

model_xgb.predict_proba(X_test_lime)

array([[7.9646105e-01, 2.0353897e-01],
       [9.5173013e-01, 4.8269872e-02],
       [7.9344827e-01, 2.0655173e-01],
       ...,
       [9.9031430e-01, 9.6856682e-03],
       [6.4581633e-04, 9.9935418e-01],
       [9.7104281e-01, 2.8957171e-02]], dtype=float32)

print(features,
      class_names,
      categorical_features,
      categorical_names)

['age', 'workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country'] ['<=50K' '>50K'] [1, 3, 5, 6, 7, 8, 9, 13] {'workclass': array(['?', 'Federal-gov', 'Local-gov', 'Never-worked', 'Private',
       'Self-emp-inc', 'Self-emp-not-inc', 'State-gov', 'Without-pay'],
      dtype=object), 'education': array(['10th', '11th', '12th', '1st-4th', '5th-6th', '7th-8th', '9th',
       'Assoc-acdm', 'Assoc-voc', 'Bachelors', 'Doctorate', 'HS-grad',
       'Masters', 'Preschool', 'Prof-school', 'Some-college'],
      dtype=object), 'marital': array(['Divorced', 'Married-AF-spouse', 'Married-civ-spouse',
       'Married-spouse-absent', 'Never-married', 'Separated', 'Widowed'],
      dtype=object), 'occupation': array(['?', 'Adm-clerical', 'Armed-Forces', 'Craft-repair',
       'Exec-managerial', 'Farming-fishing', 'Handlers-cleaners',
       'Machine-op-inspct', 'Other-service', 'Priv-house-serv',
       'Prof-specialty', 'Protective-serv', 'Sales', 'Tech-support',
       'Transport-moving'], dtype=object), 'relationship': array(['Husband', 'Not-in-family', 'Other-relative', 'Own-child',
       'Unmarried', 'Wife'], dtype=object), 'race': array(['Amer-Indian-Eskimo', 'Asian-Pac-Islander', 'Black', 'Other',
       'White'], dtype=object), 'sex': array(['Female', 'Male'], dtype=object), 'native_country': array(['?', 'Cambodia', 'Canada', 'China', 'Columbia', 'Cuba',
       'Dominican-Republic', 'Ecuador', 'El-Salvador', 'England',
       'France', 'Germany', 'Greece', 'Guatemala', 'Haiti', 'Honduras',
       'Hong', 'Hungary', 'India', 'Iran', 'Ireland', 'Italy', 'Jamaica',
       'Japan', 'Laos', 'Mexico', 'Nicaragua',
       'Outlying-US(Guam-USVI-etc)', 'Peru', 'Philippines', 'Poland',
       'Portugal', 'Puerto-Rico', 'Scotland', 'South', 'Taiwan',
       'Thailand', 'Trinadad&Tobago', 'United-States', 'Vietnam',
       'Yugoslavia'], dtype=object)}

import lime
import lime.lime_tabular
### Train should be label encoded not one hot encoded
explainer = lime.lime_tabular.LimeTabularExplainer(X_train_lime ,
                                                   feature_names = features,
                                                   class_names=class_names,
                                                   categorical_features=categorical_features, 
                                                   categorical_names=categorical_names,
                                                   kernel_width=3)



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

import numpy as np
np.random.seed(1)
i = 100
print(y_test_lime.iloc[i])
>50K

X_test_lime[i]

array([4.20000e+01, 4.00000e+00, 1.76286e+05, 7.00000e+00, 1.20000e+01,
       2.00000e+00, 4.00000e+00, 0.00000e+00, 4.00000e+00, 1.00000e+00,
       0.00000e+00, 0.00000e+00, 4.00000e+01, 3.80000e+01])


Вы можете использовать объяснитель с объяснением_экземпляра, чтобы проверить объяснение модели.

exp = explainer.explain_instance(X_test_lime[i], predict_fn, num_features=6)
exp.show_in_notebook(show_all=False)

Мы видим, что классификатор правильно предсказал домохозяйство. Доход, действительно, выше 50 тыс.

Первое, что мы можем сказать, это то, что классификатор не так уж уверен в предсказанных вероятностях. Машина предсказывает, что домохозяйство имеет доход более 50 тысяч с вероятностью 64%. Эти 64% состоят из прироста капитала и брака. Синий цвет отрицательно влияет на положительный класс, а оранжевая линия — положительно.

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

Если бы семейное положение было холостым, классификатор предсказал бы доход ниже 50 тысяч (0,64-0,18 = 0,46).

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

temp.head(3)
temp.iloc[1,:-2]

age                  58
workclass             4
fnlwgt            68624
education            11
education_num         9
marital               2
occupation            4
relationship          0
race                  4
sex                   1
capital_gain          0
capital_loss          0
hours_week           45
native_country       38
Name: 20931, dtype: object

i = 1
print('This observation is', temp.iloc[i,-2:])

This observation is label        <=50K
predicted     >50K
Name: 20931, dtype: object

exp = explainer.explain_instance(temp.iloc[1,:-2], predict_fn, num_features=6)
exp.show_in_notebook(show_all=False)

Классификатор предсказывал доход ниже 50 тысяч, но это неправда. Этот дом кажется странным. Он не имеет ни прироста капитала, ни убытка капитала. Он разведен, ему 60 лет, и он образованный человек, т.е. education_num > 12. По общей схеме это домохозяйство должно, как поясняет классификатор, получать доход ниже 50к.

Вы пытаетесь поиграть с LIME. Вы заметите грубые ошибки классификатора.

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

Резюме

Ниже приведен список некоторых полезных команд с версией scikit Learn >=0.20.

Статья является переводом guru99-com

Что такое сверточная нейронная сеть?

Сверточная нейронная сеть , также известная как консети или CNN, является хорошо известным методом в приложениях компьютерного зрения. Это класс глубоких нейронных сетей, которые используются для анализа визуальных образов. Этот тип архитектуры является доминирующим для распознавания объектов с картинки или видео. Он используется в таких приложениях, как распознавание изображений или видео, обработка нейронного языка и т. д.

Архитектура сверточной нейронной сети

Вспомните Facebook несколько лет назад, после того как вы загрузили картинку в свой профиль, вас попросили вручную добавить имя к лицу на картинке. В настоящее время Facebook использует convnet для автоматической пометки вашего друга на картинке.

Сверточная нейронная сеть для классификации изображений не очень сложна для понимания. Входное изображение обрабатывается на этапе свертки, а затем присваивается метка.

Типичная архитектура коннета может быть представлена ​​на рисунке ниже. Прежде всего, изображение передается в сеть; это называется входным изображением. Затем входное изображение проходит бесконечное количество шагов; это сверточная часть сети. Наконец, нейронная сеть может предсказать цифру на изображении.

 

Изображение состоит из массива пикселей с высотой и шириной. Изображение в градациях серого имеет только один канал, тогда как цветное изображение имеет три канала (каждый для красного, зеленого и синего). Каналы накладываются друг на друга. В этом уроке вы будете использовать изображение в градациях серого только с одним каналом. Каждый пиксель имеет значение от 0 до 255, отражающее интенсивность цвета. Например, пиксель, равный 0, будет иметь белый цвет, а пиксель со значением, близким к 255, будет темнее.

Давайте посмотрим на изображение, хранящееся в наборе данных MNIST . На рисунке ниже показано, как представить изображение слева в матричном формате. Обратите внимание, что исходная матрица была стандартизирована и находится в диапазоне от 0 до 1. Для более темного цвета значение в матрице составляет около 0,9, а значение белых пикселей равно 0.

Сверточная операция

Наиболее важным компонентом модели является сверточный слой. Эта часть направлена ​​на уменьшение размера изображения для более быстрого вычисления весов и улучшения его обобщения.

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

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

Компоненты сверточной нейронной сети (ConvNet или CNN)

Есть четыре компонента Convnets

1. свертка
2. Нелинейность (ReLU)
3. Объединение или субвыборка
4. Классификация (полностью связанный слой)

свертка

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

Свертка — это поэлементное умножение. Концепция проста для понимания. Компьютер сканирует часть изображения, обычно размером 3×3, и умножает ее на фильтр. Результат поэлементного умножения называется картой признаков. Этот шаг повторяется до тех пор, пока не будет отсканировано все изображение. Обратите внимание, что после свертки размер изображения уменьшается.

Ниже приведен URL-адрес, чтобы увидеть, как работает свертка в действии.

Доступно множество каналов. Ниже мы перечислили некоторые каналы. Вы можете видеть, что каждый фильтр имеет определенную цель. Обратите внимание, на картинке ниже; Ядро является синонимом фильтра.

Источник

Арифметика позади свертки

Фаза свертки применит фильтр к небольшому массиву пикселей в изображении. Фильтр будет перемещаться по входному изображению общей формы 3×3 или 5×5. Это означает, что сеть будет перемещать эти окна по всему входному изображению и вычислять свертки. На изображении ниже показано, как работает свертка. Размер патча — 3×3, а выходная матрица — результат поэлементной операции между матрицей изображения и фильтром.

Вы заметили, что ширина и высота вывода могут отличаться от ширины и высоты ввода. Это происходит из-за пограничного эффекта.

Эффект границы

Изображение имеет карту признаков 5×5 и фильтр 3×3. В центре есть только одно окно, где фильтр может отображать сетку 3×3. Выходная карта объектов уменьшится на две плитки вместе с размером 3 × 3.

Чтобы получить то же выходное измерение, что и входное, вам нужно добавить отступы. Заполнение состоит из добавления нужного количества строк и столбцов с каждой стороны матрицы. Это позволит свертке центрировать каждую входную плитку. На изображении ниже матрица ввода/вывода имеет одинаковую размерность 5×5.

Когда вы определяете сеть, свернутые объекты контролируются тремя параметрами:

1. Глубина : определяет количество фильтров, применяемых во время свертки. В предыдущем примере вы видели глубину 1, что означает, что используется только один фильтр. В большинстве случаев используется более одного фильтра. На рисунке ниже показаны операции, проделанные в ситуации с тремя фильтрами.

2. Шаг : определяет количество «скачков пикселя» между двумя срезами. Если шаг равен 1, окна будут перемещаться с шагом в один пиксель. Если шаг равен двум, окна будут прыгать на 2 пикселя. Если вы увеличите шаг, у вас будут меньшие карты признаков.

Пример шага 1

шаг 2

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

Нелинейность (ReLU)

В конце операции свертки выход подвергается функции активации, чтобы разрешить нелинейность. Обычная функция активации для convnet — Relu. Все пиксели с отрицательным значением будут заменены нулем.

Операция объединения

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

На этом этапе вам нужно определить размер и шаг. Стандартный способ объединения входного изображения — использовать максимальное значение карты объектов. Посмотрите на картинку ниже. «Объединение» отобразит четыре подматрицы карты объектов 4 × 4 и вернет максимальное значение. Объединение берет максимальное значение массива 2×2, а затем перемещает эти окна на два пикселя. Например, первая подматрица — [3,1,3,2], объединение вернет максимальное значение, равное 3.

Существует еще одна операция объединения, такая как среднее.

Эта операция агрессивно уменьшает размер карты объектов.

Полностью связанные слои

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

Резюме:

Сверточная нейронная сеть TensorFlow компилирует различные слои, прежде чем делать прогноз. Нейронная сеть имеет:

• Сверточный слой
• Функция активации Relu
• Объединенный слой
• Плотно связанный слой

Сверточные слои применяют различные фильтры к части изображения. Функция активации Relu добавляет нелинейность, а объединяющие слои уменьшают размерность карт объектов.

Все эти слои извлекают из изображений важную информацию. Наконец, карта объектов передается на основной полносвязный слой с функцией softmax для прогнозирования.

Обучите CNN с помощью TensorFlow

Теперь, когда вы знакомы со строительным блоком коннета, вы готовы создать его с помощью TensorFlow. Мы будем использовать набор данных MNIST для классификации изображений CNN.

Подготовка данных такая же, как и в предыдущем уроке. Вы можете запустить коды и сразу перейти к архитектуре CNN.

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

Шаг 1. Загрузите набор данных

Шаг 2: Входной слой

Шаг 3: Сверточный слой

Шаг 4: Объединение слоев

Шаг 5: Второй сверточный слой и объединяющий слой

Шаг 6: Плотный слой

Шаг 7: Логит-уровень

Шаг 1. Загрузите набор данных

Набор данных MNIST доступен в scikit для изучения по этому URL -адресу . Загрузите его и сохраните в разделе «Загрузки». Вы можете загрузить его с помощью fetch_mldata(‘MNIST original’).

Создайте набор поездов/тестов

Вам нужно разделить набор данных с помощью train_test_split

Масштабировать функции

Наконец, вы можете масштабировать функцию с помощью MinMaxScaler, как показано в приведенной ниже классификации изображений, используя пример TensorFlow CNN.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))
feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]
X_train_scaled.shape[1:]

Дайте определение CNN

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

1. Сверточный слой: примените n фильтров к карте объектов. После свертки вам нужно использовать функцию активации Relu, чтобы добавить нелинейность в сеть.
2. Слой пула: Следующим шагом после свертки является понижение дискретизации максимального признака. Цель состоит в том, чтобы уменьшить размерность карты объектов, чтобы предотвратить переоснащение и повысить скорость вычислений. Максимальное объединение — это традиционный метод, который делит карты объектов на подрегионы (обычно размером 2 × 2) и сохраняет только максимальные значения.
3. Полностью связанные слои: все нейроны из предыдущих слоев подключены к следующим слоям. CNN классифицирует метку в соответствии с функциями из сверточных слоев и сокращается с помощью слоя объединения.

Архитектура CNN

• Сверточный слой: применяет 14 фильтров 5 × 5 (извлечение подобластей 5 × 5 пикселей) с функцией активации ReLU.
• Слой объединения: выполняет максимальное объединение с фильтром 2 × 2 и шагом 2 (что указывает, что объединенные области не перекрываются).
• Сверточный слой: применяет 36 фильтров 5 × 5 с функцией активации ReLU.
• Слой объединения № 2: снова выполняет максимальное объединение с фильтром 2 × 2 и шагом 2.
• 1764 нейрона с коэффициентом регуляризации отсева 0,4 (вероятность 0,4 того, что любой данный элемент будет отброшен во время обучения)
• Плотный слой (логит-слой): 10 нейронов, по одному на каждый целевой класс цифр (0–9).

Есть три важных модуля, которые можно использовать для создания CNN:

• конв2д(). Создает двумерный сверточный слой с количеством фильтров, размером ядра фильтра, дополнением и функцией активации в качестве аргументов.
• max_pooling2d(). Создает двумерный слой объединения с использованием алгоритма максимального объединения.
• плотный(). Создает плотный слой со скрытыми слоями и единицами

Вы определите функцию для построения CNN. Давайте подробно рассмотрим, как построить каждый стандартный блок, прежде чем объединить все вместе в функции.

Шаг 2: Входной слой

def cnn_model_fn(features, labels, mode):
    input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

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

Картинка имеет высоту, ширину и канал. Набор данных MNIST представляет собой монохронное изображение размером 28×28. Мы устанавливаем размер пакета равным -1 в аргументе формы, чтобы он принимал форму функций [“x”]. Преимущество состоит в том, чтобы настроить гиперпараметры размера пакета. Если размер пакета установлен на 7, то тензор будет передавать 5488 значений (28 * 28 * 7).

Шаг 3: Сверточный слой

# first Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

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

Вы используете функцию активации Relu. Выходной размер будет [28, 28, 14].

Шаг 4: Объединение слоев

Следующим шагом после свертки является вычисление пула. Вычисление объединения уменьшит размерность данных. Вы можете использовать модуль max_pooling2d с размером 2×2 и шагом 2. Вы используете предыдущий слой в качестве входных данных. Выходной размер будет [batch_size, 14, 14, 14]

# first Pooling Layer 
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Шаг 5: Второй сверточный слой и объединяющий слой

Второй сверточный слой имеет 32 фильтра с выходным размером [batch_size, 14, 14, 32]. Слой пула имеет тот же размер, что и раньше, а выходная форма — [batch_size, 14, 14, 18].

conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

Шаг 6: Плотный слой

Затем вам нужно определить полносвязный слой. Карта объектов должна быть сглажена, прежде чем ее можно будет соединить с плотным слоем. Вы можете использовать модуль reshape размером 7*7*36.

Плотный слой соединит 1764 нейрона. Вы добавляете функцию активации Relu. Кроме того, вы добавляете член регуляризации отсева со скоростью 0,3, что означает, что 30 процентов весов будут установлены на 0. Обратите внимание, что отсев происходит только на этапе обучения. Функция cnn_model_fn имеет режим аргумента, чтобы объявить, нужно ли обучать модель или оценивать ее, как показано в приведенном ниже примере TensorFlow с классификацией изображений CNN.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Шаг 7: Логит-уровень

Наконец, в примере классификации изображений TensorFlow вы можете определить последний слой с прогнозом модели. Выходная форма равна размеру пакета и 10 — общему количеству изображений.

# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)



Вы можете создать словарь, содержащий классы и вероятность каждого класса. Модуль tf.argmax() возвращает максимальное значение, если логит-уровни. Функция softmax возвращает вероятность каждого класса.

predictions = {				
	# Generate predictions				
    "classes": tf.argmax(input=logits, axis=1),				
    "probabilities": tf.nn.softmax(logits, name="softmax_tensor")  }	





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

if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)



Следующий шаг состоит в вычислении потерь модели. Из последнего урока вы узнали, что функция потерь для мультиклассовой модели — это перекрестная энтропия. Потеря легко вычисляется с помощью следующего кода:

# Calculate Loss (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)





Последним шагом примера TensorFlow CNN является оптимизация модели, то есть поиск наилучших значений весов. Для этого вы используете оптимизатор градиентного спуска со скоростью обучения 0,001. Цель – минимизировать потери

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())




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

eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)





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

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

  # Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=32,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

  # Pooling Layer
  pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

  # Convolutional Layer #2 and Pooling Layer
  conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
  pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

  # Dense Layer
  pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])
  dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
  dropout = tf.layers.dropout(
      inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)

  # Logits Layer
  logits = tf.layers.dense(inputs=dropout, units=10)

  predictions = {
      # Generate predictions (for PREDICT and EVAL mode)
      "classes": tf.argmax(input=logits, axis=1),
      "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
  }

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  # Calculate Loss
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

  # Configure the Training Op (for TRAIN mode)
  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
    train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

  # Add evaluation metrics Evaluation mode
  eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(
          labels=labels, predictions=predictions["classes"])}
  return tf.estimator.EstimatorSpec(
      mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Шаги ниже аналогичны предыдущим урокам.

Прежде всего, вы определяете оценщик с моделью CNN для классификации изображений.

# Create the Estimator
mnist_classifier = tf.estimator.Estimator(
    model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")




Обучение CNN занимает много времени, поэтому вы создаете крючок Logging для хранения значений слоев softmax каждые 50 итераций.

# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)                                       



Вы готовы оценить модель. Вы устанавливаете размер пакета 100 и перемешиваете данные. Обратите внимание, что мы установили шаги обучения 16 000, обучение может занять много времени. Потерпи.

# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=100,
    num_epochs=None,
    shuffle=True)
mnist_classifier.train(
    input_fn=train_input_fn,
    steps=16000,
    hooks=[logging_hook]) 




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

# Evaluate the model and print results
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test,
    num_epochs=1,
    shuffle=False)
eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
print(eval_results)

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269
{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}

С текущей архитектурой вы получаете точность 97%. Вы можете изменить архитектуру, размер пакета и количество итераций, чтобы повысить точность. Нейронная сеть CNN работает намного лучше, чем ANN или логистическая регрессия. В учебнике по искусственной нейронной сети у вас была точность 96%, что ниже CNN. Производительность CNN впечатляет большим набором изображений , как с точки зрения скорости вычислений, так и точности.

Резюме

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

Чтобы построить TensorFlow CNN, вам нужно выполнить семь шагов:

Шаг 1 : Загрузите набор данных:

Набор данных MNIST доступен для изучения с помощью scikit. Загрузите его и сохраните в разделе «Загрузки». Вы можете загрузить его с помощью fetch_mldata(‘MNIST original’).

Шаг 2 : Входной слой:

Этот шаг изменяет форму данных. Форма равна квадратному корню из числа пикселей. Например, если изображение имеет 156 пикселей, то форма будет 26×26. Вам нужно указать, имеет ли изображение цвет или нет. Если да, то у вас было 3 формы – 3 для RGB-, иначе 1.

input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Шаг 3 : Сверточный слой

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

conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

Шаг 4 : Объединение слоев

На третьем шаге вы добавляете объединяющий слой. Этот слой уменьшает размер ввода. Он делает это, беря максимальное значение подматрицы a. Например, если подматрица равна [3,1,3,2], объединение вернет максимальное значение, равное 3.

pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Шаг 5 : Добавьте сверточный слой и объединяющий слой

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

Шаг 6 : Плотный слой

Шаг 6 сглаживает предыдущий, чтобы создать полностью связанные слои. На этом этапе вы можете использовать другую функцию активации и добавить эффект исключения.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Шаг 7 : Логит-уровень

Завершающим этапом является предсказание.

logits = tf.layers.dense(inputs=dropout, units=10)

Статья является переводом https://www.guru99.com/

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

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

Работа автоэнкодера
Работа автоэнкодера

Работа автоэнкодера
Модель обновит веса, минимизируя функцию потерь. Модель наказывается, если выходные данные реконструкции отличаются от входных.

Конкретно представьте картинку размером 50×50 (т. е. 250 пикселей) и нейронную сеть только с одним скрытым слоем, состоящим из ста нейронов. Обучение проводится на карте признаков, которая в два раза меньше входной. Это означает, что сети нужно найти способ реконструировать 250 пикселей только с вектором нейронов, равным 100.

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

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

Другое полезное семейство Autoencoder Deep Learning — это вариационный автоэнкодер. Этот тип сети может генерировать новые изображения. Представьте, что вы тренируете сеть с изображением мужчины; такая сеть может создавать новые лица.

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

Вы будете использовать набор данных CIFAR-10 , который содержит 60000 цветных изображений 32×32. Набор данных Autoencoder уже разделен на 50 000 изображений для обучения и 10 000 для тестирования. Существует до десяти классов:

Самолет
Автомобиль
Птица
Кошка
Олень
Собака
Лягушка
Лошадь
Судно
Грузовая машина
Вам необходимо загрузить изображения по этому URL-адресу https://www.cs.toronto.edu/~kriz/cifar.html и разархивировать его. Папка for-10-batches-py содержит пять пакетов данных по 10000 изображений в каждом в случайном порядке.

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

Импорт данных
Преобразование данных в черно-белый формат
Добавить все пакеты
Создайте обучающий набор данных
Создайте визуализатор изображений
Предварительная обработка изображения
Шаг 1) Импорт данных

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

import numpy as np
import tensorflow as tf
import pickle
def unpickle(file):
import pickle
with open(file, ‘rb’) as fo:
dict = pickle.load(fo, encoding=’latin1′)
return dict

Шаг 2) Преобразуйте данные в черно-белый формат

Для простоты вы преобразуете данные в оттенки серого. То есть только с одним измерением вместо трех для цветового изображения. Большая часть нейронной сети работает только с одним входным параметром.
def grayscale(im):
return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

Шаг 3) Добавьте все пакеты

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

Когда этот шаг выполнен, вы конвертируете данные цветов в формат шкалы серого. Как видите, форма данных 50000 и 1024. Теперь 32*32 пикселя сглажены до 2014 года.

# Load the data into memory
data, labels = [], []
## Loop over the b
for i in range(1, 6):
filename = ‘./cifar-10-batches-py/data_batch_’ + str(i)
open_data = unpickle(filename)
if len(data) > 0:
data = np.vstack((data, open_data[‘data’]))
labels = np.hstack((labels, open_data[‘labels’]))
else:
data = open_data[‘data’]
labels = open_data[‘labels’]

data = grayscale(data)
x = np.matrix(data)
y = np.array(labels)
print(x.shape)
(50000, 1024)

римечание. Измените «./cifar-10-batches-py/data_batch_» на фактическое местоположение вашего файла. Например, для компьютера с Windows путь может быть следующим: filename = ‘E:\cifar-10-batches-py\data_batch_’ + str(i)

Шаг 4) Создайте набор обучающих данных

Чтобы сделать обучение более быстрым и легким, вы будете тренировать модель только на изображениях лошади. Лошади являются седьмым классом в данных этикетки. Как указано в документации набора данных CIFAR-10, каждый класс содержит 5000 изображений. Вы можете распечатать форму данных, чтобы подтвердить наличие 5000 изображений с 1024 столбцами, как показано в приведенном ниже примере шага автоэнкодера TensorFlow .

horse_i = np.where(y == 7)[0]
horse_x = x[horse_i]
print(np.shape(horse_x))
(5000, 1024)

Шаг 5) Создайте визуализатор изображений

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

Простой способ распечатать изображения — использовать объект imshow из библиотеки matplotlib. Обратите внимание, что вам нужно преобразовать форму данных из 1024 в 32*32 (т.е. формат изображения).

# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
def plot_image(image, shape=[32, 32], cmap = “Greys_r”):
plt.imshow(image.reshape(shape), cmap=cmap,interpolation=”nearest”)
plt.axis(“off”)

Функция принимает 3 аргумента:

Изображение : ввод
Форма : список, размер изображения
Cmap : выберите цветовую карту. По умолчанию серый
Вы можете попытаться построить первое изображение в наборе данных. Вы должны увидеть человека на лошади.

plot_image(horse_x[1], shape=[32, 32], cmap = “Greys_r”)

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

Вы создадите набор данных с оценщиком TensorFlow. Чтобы освежить свой разум, вам нужно использовать:

from_tensor_slices
повторение
партия
Полный код для создания набора данных:

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)

Обратите внимание, что x — это заполнитель со следующей формой:

[None,n_inputs]: установите значение «Нет», так как количество изображений, передаваемых в сеть, равно размеру пакета.
подробности см. в учебнике по линейной регрессии.

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

iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()

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

Вы установили размер пакета равным 1, потому что хотите загрузить в набор данных только одно изображение. Вы можете увидеть размер данных с помощью print(sess.run(features).shape). Он равен (1, 1024). 1 означает, что подается только одно изображение с разрешением 1024. Если размер пакета установлен равным двум, то два изображения будут проходить через конвейер. (Не изменяйте размер пакета. В противном случае будет выдана ошибка. В функцию plot_image() может передаваться только одно изображение за раз.

## Parameters
n_inputs = 32 * 32
BATCH_SIZE = 1
batch_size = tf.placeholder(tf.int64)

# using a placeholder
x = tf.placeholder(tf.float32, shape=[None,n_inputs])
## Dataset
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
iter = dataset.make_initializable_iterator() # create the iterator
features = iter.get_next()

## Print the image
with tf.Session() as sess:
# feed the placeholder with data
sess.run(iter.initializer, feed_dict={x: horse_x,
batch_size: BATCH_SIZE})
print(sess.run(features).shape)
plot_image(sess.run(features), shape=[32, 32], cmap = “Greys_r”)
(1, 1024)

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

Ваша сеть будет иметь один входной слой с 1024 точками, то есть 32×32, формой изображения.

Блок кодировщика будет иметь один верхний скрытый слой с 300 нейронами и центральный слой со 150 нейронами. Блок декодера симметричен кодеру. Вы можете визуализировать сеть на картинке ниже. Обратите внимание, что вы можете изменить значения скрытых и центральных слоев.

Построение сети для Autoencoder
Построение сети для Autoencoder

Создание автоэнкодера очень похоже на любую другую модель глубокого обучения.

Вы построите модель, выполнив следующие шаги:

Определите параметры
Определите слои
Определить архитектуру
Определите оптимизацию
Запустите модель
Оценить модель
В предыдущем разделе вы узнали, как создать конвейер для подачи модели, поэтому нет необходимости создавать набор данных еще раз. Вы создадите автоэнкодер с четырьмя слоями. Вы используете инициализацию Xavier. Это метод установки начальных весов равными дисперсии входных и выходных данных. Наконец, вы используете функцию активации elu. Вы регуляризуете функцию потерь с помощью регуляризатора L2.

Шаг 1) Определите параметры

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

Перед этим вы импортируете функцию частично. Это лучший метод определения параметров плотных слоев. В приведенном ниже коде определяются значения архитектуры автоэнкодера. Как упоминалось ранее, автоэнкодер имеет два слоя: 300 нейронов в первых слоях и 150 во вторых слоях. Их значения хранятся в n_hidden_1 и n_hidden_2.

Вам необходимо определить скорость обучения и гиперпараметр L2. Значения хранятся в Learning_rate и l2_reg

from functools import partial

## Encoder
n_hidden_1 = 300
n_hidden_2 = 150 # codings

## Decoder
n_hidden_3 = n_hidden_1
n_outputs = n_inputs

learning_rate = 0.01
l2_reg = 0.0001

Техника инициализации Xavier вызывается с помощью объекта xavier_initializer из оценщика contrib. В тот же оценщик можно добавить регуляризатор с помощью l2_regularizer

## Define the Xavier initialization
xav_init = tf.contrib.layers.xavier_initializer()
## Define the L2 regularizer
l2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

Шаг 2) Определите слои

Все параметры плотных слоев заданы; вы можете упаковать все в переменную плотности_слоя, используя партиал объекта. плотный_слой, который использует активацию ELU, инициализацию Xavier и регуляризацию L2.

## Create the dense layer
dense_layer = partial(tf.layers.dense,
activation=tf.nn.elu,
kernel_initializer=xav_init,
kernel_regularizer=l2_regularizer)

Шаг 3) Определите архитектуру

Если вы посмотрите на изображение архитектуры, вы заметите, что сеть объединяет три слоя с выходным слоем. В приведенном ниже коде вы соединяете соответствующие слои. Например, первый слой вычисляет скалярное произведение между входными матричными функциями и матрицами, содержащими 300 весов. После того, как скалярное произведение вычислено, результат поступает в функцию активации Elu. Выход становится входом следующего слоя, поэтому вы используете его для вычисления hidden_2 и так далее. Умножение матриц одинаково для каждого слоя, потому что вы используете одну и ту же функцию активации. Обратите внимание, что последний слой, выходные данные, не применяет функцию активации. Это имеет смысл, потому что это реконструированный ввод

## Make the mat mul
hidden_1 = dense_layer(features, n_hidden_1)
hidden_2 = dense_layer(hidden_1, n_hidden_2)
hidden_3 = dense_layer(hidden_2, n_hidden_3)
outputs = dense_layer(hidden_3, n_outputs, activation=None)

Шаг 4) Определите оптимизацию

Последним шагом является создание оптимизатора. Вы используете среднеквадратичную ошибку в качестве функции потерь. Если вы помните учебник по линейной регрессии, вы знаете, что MSE вычисляется с разницей между прогнозируемым результатом и реальной меткой. Здесь метка является функцией, потому что модель пытается восстановить входные данные. Следовательно, вам нужно среднее значение суммы разности квадратов между прогнозируемым выходом и входом. С помощью TensorFlow вы можете закодировать функцию потерь следующим образом:

loss = tf.reduce_mean(tf.square(outputs – features))

Затем вам нужно оптимизировать функцию потерь. Вы используете оптимизатор Adam для вычисления градиентов. Целевой функцией является минимизация потерь.

## Optimize
loss = tf.reduce_mean(tf.square(outputs – features))
optimizer = tf.train.AdamOptimizer(learning_rate)
train = optimizer.minimize(loss)

Еще одна настройка перед обучением модели. Вы хотите использовать размер пакета 150, то есть передавать конвейеру 150 изображений на каждой итерации. Вам нужно вычислить количество итераций вручную. Это тривиально сделать:

Если вы хотите передавать 150 изображений каждый раз и знаете, что в наборе данных 5000 изображений, количество итераций равно . В python вы можете запустить следующие коды и убедиться, что вывод равен 33:

BATCH_SIZE = 150
### Number of batches : length dataset / batch size
n_batches = horse_x.shape[0] // BATCH_SIZE
print(n_batches)
33

Шаг 5) Запустите модель

И последнее, но не менее важное: обучите модель. Вы тренируете модель со 100 эпохами. То есть модель увидит в 100 раз больше изображений с оптимизированными весами.

Вы уже знакомы с кодами для обучения модели в Tensorflow. Небольшая разница заключается в передаче данных перед запуском обучения. Таким образом модель тренируется быстрее.

Вам нужно распечатать потери через десять эпох, чтобы увидеть, учится ли модель чему-то (т. е. уменьшается ли потеря). Обучение занимает от 2 до 5 минут, в зависимости от аппаратного обеспечения вашей машины.

## Set params
n_epochs = 100

## Call Saver to save the model and re-use it later during evaluation
saver = tf.train.Saver()

with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# initialise iterator with train data
sess.run(iter.initializer, feed_dict={x: horse_x,
batch_size: BATCH_SIZE})
print(‘Training…’)
print(sess.run(features).shape)
for epoch in range(n_epochs):
for iteration in range(n_batches):
sess.run(train)
if epoch % 10 == 0:
loss_train = loss.eval() # not shown
print(“\r{}”.format(epoch), “Train MSE:”, loss_train)
#saver.save(sess, “./my_model_all_layers.ckpt”)
save_path = saver.save(sess, “./model.ckpt”)
print(“Model saved in path: %s” % save_path)
Training…
(150, 1024)
0 Train MSE: 2934.455
10 Train MSE: 1672.676
20 Train MSE: 1514.709
30 Train MSE: 1404.3118
40 Train MSE: 1425.058
50 Train MSE: 1479.0631
60 Train MSE: 1609.5259
70 Train MSE: 1482.3223
80 Train MSE: 1445.7035
90 Train MSE: 1453.8597
Model saved in path: ./model.ckpt

Шаг 6) Оцените модель

Теперь, когда вы обучили свою модель, пришло время оценить ее. Вам необходимо импортировать набор тестов из файла /cifar-10-batches-py/.

test_data = unpickle(‘./cifar-10-batches-py/test_batch’)
test_x = grayscale(test_data[‘data’])
#test_labels = np.array(test_data[‘labels’])

ПРИМЕЧАНИЕ . Для компьютера с Windows код становится test_data = unpickle(r”E:\cifar-10-batches-py\test_batch”).

Вы можете попробовать распечатать изображения 13, на которых изображена лошадь.

plot_image(test_x[13], shape=[32, 32], cmap = “Greys_r”)
Построение сети для Autoencoder
Чтобы оценить модель, вы будете использовать значение пикселя этого изображения и посмотреть, сможет ли кодировщик восстановить то же изображение после сжатия на 1024 пикселя. Обратите внимание, что вы определяете функцию для оценки модели на разных изображениях. Модель должна лучше работать только на лошадях.

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

df : импорт тестовых данных
image_number : укажите, какое изображение импортировать
Функция разделена на три части:

Измените изображение на правильный размер, т.е. 1, 1024
Скармливайте модели невидимое изображение, кодируйте/декодируйте изображение
Распечатайте реальное и реконструированное изображение

def reconstruct_image(df, image_number = 1):
## Part 1: Reshape the image to the correct dimension i.e 1, 1024
x_test = df[image_number]
x_test_1 = x_test.reshape((1, 32*32))

## Part 2: Feed the model with the unseen image, encode/decode the image
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
sess.run(iter.initializer, feed_dict={x: x_test_1,
batch_size: 1})
## Part 3: Print the real and reconstructed image
# Restore variables from disk.
saver.restore(sess, “./model.ckpt”)
print(“Model restored.”)
# Reconstruct image
outputs_val = outputs.eval()
print(outputs_val.shape)
fig = plt.figure()
# Plot real
ax1 = fig.add_subplot(121)
plot_image(x_test_1, shape=[32, 32], cmap = “Greys_r”)
# Plot estimated
ax2 = fig.add_subplot(122)
plot_image(outputs_val, shape=[32, 32], cmap = “Greys_r”)
plt.tight_layout()
fig = plt.gcf()

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

reconstruct_image(df =test_x, image_number = 13)
INFO:tensorflow:Restoring parameters from ./model.ckpt
Model restored.
(1, 1024)

Резюме
Основная цель автоэнкодера — сжать входные данные, а затем распаковать их в выходные данные, очень похожие на исходные данные.
Архитектура автоэнкодера, симметричная с опорным слоем, называемым центральным слоем.
Вы можете создать автоэнкодер, используя:
Частичный : для создания плотных слоев с типичными настройками:

tf.layers.dense,
activation=tf.nn.elu,
kernel_initializer=xav_init,
kernel_regularizer=l2_regularizer

плотности_слоя() : сделать матричное умножение

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

loss = tf.reduce_mean(tf.square(outputs – features))
optimizer = tf.train.AdamOptimizer(learning_rate)
train = optimizer.minimize(loss)

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

Статья является переводом www.guru99.com

Что такое линейный классификатор?
Линейный классификатор в машинном обучении — это метод поиска класса объекта на основе его характеристик для статистической классификации. Он принимает классификационное решение на основе значения линейной комбинации характеристик объекта. Линейный классификатор используется в практических задачах, таких как классификация документов и задачи с множеством переменных.

Проблемы классификации составляют примерно 80 процентов задач машинного обучения. Классификация направлена ​​на прогнозирование вероятности каждого класса с учетом набора входных данных. Метка (т. е. зависимая переменная) представляет собой дискретное значение, называемое классом.

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

Теоретическая часть этого руководства уделяет основное внимание двоичному классу. Вы узнаете больше о функции вывода мультикласса в будущем руководстве.

Как работает бинарный классификатор?
В предыдущем уроке вы узнали, что функция состоит из двух типов переменных: зависимой переменной и набора функций (независимых переменных). В линейной регрессии зависимая переменная представляет собой действительное число без диапазона. Основная цель состоит в том, чтобы предсказать его значение путем минимизации среднеквадратичной ошибки.

Для бинарного классификатора TensorFlow метка может иметь два возможных целочисленных значения. В большинстве случаев это либо [0,1], либо [1,2]. Например, цель состоит в том, чтобы предсказать, купит ли клиент продукт или нет. Метка определяется следующим образом:

Y = 1 (покупатель купил товар)
Y = 0 (покупатель не покупает товар)
Модель использует признаки X для классификации каждого покупателя в наиболее вероятном классе, к которому он принадлежит, а именно, потенциальный покупатель или нет.

Вероятность успеха вычисляется с помощью логистической регрессии . Алгоритм будет вычислять вероятность на основе функции X и предсказывает успех, когда эта вероятность превышает 50 процентов. Более формально вероятность рассчитывается, как показано в приведенном ниже примере бинарной классификации TensorFlow:

Пример бинарной классификации
где 0 — набор весов, признаков и b — смещение.

Функцию можно разбить на две части:

Линейная модель
Логистическая функция
Линейная модель
Вы уже знакомы с тем, как рассчитываются веса. Веса вычисляются с помощью скалярного произведения:Скалярное произведениеY является линейной функцией всех признаков x i . Если в модели нет признаков, прогноз равен смещению, б.

Веса указывают направление корреляции между признаками x i и меткой y. Положительная корреляция увеличивает вероятность положительного класса, в то время как отрицательная корреляция приближает вероятность к 0 (т. е. к отрицательному классу).

Линейная модель возвращает только действительное число, что несовместимо с вероятностной мерой диапазона [0,1]. Логистическая функция необходима для преобразования выходных данных линейной модели в вероятность,

Логистическая функция
Логистическая функция, или сигмовидная функция, имеет S-образную форму, и выход этой функции всегда находится между 0 и 1.

Пример логистической функции
Пример логистической функции
Пример логистической функции

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

Классификатор может преобразовать вероятность в класс

Значения от 0 до 0,49 становятся классом 0
Значения от 0,5 до 1 становятся классом 1
Как измерить производительность линейного классификатора?
Точность
Общая производительность классификатора измеряется метрикой точности. Точность собирает все правильные значения, разделенные на общее количество наблюдений. Например, значение точности 80 процентов означает, что модель верна в 80 процентах случаев.

Измерьте производительность линейного классификатора с помощью метрики точности
Измерьте производительность линейного классификатора с помощью метрики точности

Вы можете отметить недостаток этой метрики, особенно для класса дисбаланса. Набор данных о дисбалансе возникает, когда количество наблюдений в группе не равно. скажем; вы пытаетесь классифицировать редкое событие с помощью логистической функции. Представьте, что классификатор пытается оценить смерть пациента после болезни. По данным, 5 процентов пациентов умирают. Вы можете научить классификатор предсказывать количество смертей и использовать метрику точности для оценки производительности. Если классификатор предсказывает 0 смертей для всего набора данных, он будет правильным в 95% случаев.

Матрица путаницы
Лучший способ оценить эффективность классификатора — посмотреть на матрицу путаницы.

Измерьте производительность линейного классификатора, используя матрицу путаницы
Измерьте производительность линейного классификатора, используя матрицу путаницы

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

TP: True Positive: предсказанные значения правильно предсказаны как фактические положительные
FP: предсказанные значения неверно предсказали фактическое положительное значение. т. е. отрицательные значения прогнозируются как положительные
FN: ложноотрицательный: положительные значения прогнозируются как отрицательные
TN: True Negative: предсказанные значения правильно предсказаны как фактические отрицательные значения.
Из матрицы путаницы легко сравнить фактический класс и прогнозируемый класс.

Точность и чувствительность
Матрица путаницы дает хорошее представление о истинно положительном и ложноположительном результате. В некоторых случаях предпочтительнее иметь более краткую метрику.

Точность

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

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

Чувствительность

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

Линейный классификатор с TensorFlow
В этом руководстве мы будем использовать набор данных переписи. Цель состоит в том, чтобы использовать переменные в наборе данных переписи для прогнозирования уровня дохода. Обратите внимание, что доход является бинарной переменной

со значением 1, если доход > 50k
0, если доход < 50 тыс.
Эта переменная является вашей меткой

На этом примере классификации TensorFlow вы поймете, как обучать линейные классификаторы TensorFlow с помощью оценщика TensorFlow и как улучшить показатель точности.

Мы будем действовать следующим образом:

Шаг 1) Импорт данных
Шаг 2) Преобразование данных
Шаг 3) Обучите классификатор
Шаг 4) Улучшить модель
Шаг 5) Гиперпараметр: Лассо и Ридж
Шаг 1) Импорт данных
Сначала вы импортируете библиотеки, используемые во время обучения.

import tensorflow as tf
import pandas as pd

Далее вы импортируете данные из архива UCI и определяете имена столбцов. Вы будете использовать COLUMNS для именования столбцов в фрейме данных pandas.

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

## Define path data
COLUMNS = [‘age’,’workclass’, ‘fnlwgt’, ‘education’, ‘education_num’, ‘marital’,
‘occupation’, ‘relationship’, ‘race’, ‘sex’, ‘capital_gain’, ‘capital_loss’,
‘hours_week’, ‘native_country’, ‘label’]
PATH = “https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data”
PATH_test = “https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test”

Данные, хранящиеся в сети, уже разделены между набором поездов и набором тестов.

df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False)
df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)

Набор поездов содержит 32 561 наблюдение, а тестовый набор — 16 281.

print(df_train.shape, df_test.shape)
print(df_train.dtypes)
(32561, 15) (16281, 15)
age int64
workclass object
fnlwgt int64
education object
education_num int64
marital object
occupation object
relationship object
race object
sex object
capital_gain int64
capital_loss int64
hours_week int64
native_country object
label object
dtype: object

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

label = {‘<=50K’: 0,’>50K’: 1}
df_train.label = [label[item] for item in df_train.label]
label_t = {‘<=50K.’: 0,’>50K.’: 1}
df_test.label = [label_t[item] for item in df_test.label]

В данных поезда есть 24 720 доходов ниже 50 тысяч и 7841 выше. Соотношение почти такое же для тестового набора.
Пожалуйста, обратитесь к этому руководству по Facets для получения дополнительной информации.

print(df_train[“label”].value_counts())
### The model will be correct in atleast 70% of the case
print(df_test[“label”].value_counts())
## Unbalanced label
print(df_train.dtypes)
0 24720
1 7841
Name: label, dtype: int64
0 12435
1 3846
Name: label, dtype: int64
age int64
workclass object
fnlwgt int64
education object
education_num int64
marital object
occupation object
relationship object
race object
sex object
capital_gain int64
capital_loss int64
hours_week int64
native_country object
label int64
dtype: object

Шаг 2) Преобразование данных
Перед обучением линейного классификатора с помощью Tensorflow необходимо выполнить несколько шагов.
Вам необходимо подготовить функции для включения в модель.
В эталонной регрессии вы будете использовать исходные данные без применения каких-либо преобразований.

Оценщик должен иметь список функций для обучения модели. Следовательно, данные столбца необходимо преобразовать в тензор.

Хорошей практикой является определение двух списков функций на основе их типа, а затем передача их в feature_columns оценщика.

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

Характеристики набора данных имеют два формата:

Целое число
Объект
Каждая функция указана в следующих двух переменных в соответствии с их типами.

## Add features to the bucket:
### Define continuous list
CONTI_FEATURES = [‘age’, ‘fnlwgt’,’capital_gain’, ‘education_num’, ‘capital_loss’, ‘hours_week’]
### Define the categorical list
CATE_FEATURES = [‘workclass’, ‘education’, ‘marital’, ‘occupation’, ‘relationship’, ‘race’, ‘sex’, ‘native_country’]

Feature_column оснащен объектом numeric_column, чтобы помочь в преобразовании непрерывных переменных в тензор. В приведенном ниже коде вы конвертируете все переменные из CONTI_FEATURES в тензор с числовым значением. Это обязательно для построения модели. Все независимые переменные должны быть преобразованы в правильный тип тензора.

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

def print_transformation(feature = “age”, continuous = True, size = 2):
#X = fc.numeric_column(feature)
## Create feature name
feature_names = [
feature]

## Create dict with the data
d = dict(zip(feature_names, [df_train[feature]]))

## Convert age
if continuous == True:
c = tf.feature_column.numeric_column(feature)
feature_columns = [c]
else:
c = tf.feature_column.categorical_column_with_hash_bucket(feature, hash_bucket_size=size)
c_indicator = tf.feature_column.indicator_column(c)
feature_columns = [c_indicator]

## Use input_layer to print the value
input_layer = tf.feature_column.input_layer(
features=d,
feature_columns=feature_columns
)
## Create lookup table
zero = tf.constant(0, dtype=tf.float32)
where = tf.not_equal(input_layer, zero)
## Return lookup tble
indices = tf.where(where)
values = tf.gather_nd(input_layer, indices)
## Initiate graph
sess = tf.Session()
## Print value
print(sess.run(input_layer))
print_transformation(feature = “age”, continuous = True)
[[39.]
[50.]
[38.]
…
[58.]
[22.]
[52.]]

Значения точно такие же, как в df_train

continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]

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

Например, если статус переменной имеет три различных значения:

Муж
Жена
Одинокий
Затем будут присвоены три идентификатора. Например, у мужа будет ID 1, у жены ID 2 и так далее.

Для иллюстрации вы можете использовать этот код для преобразования объектной переменной в категориальный столбец в TensorFlow.

Признак пола может иметь только два значения: мужской или женский. Когда мы преобразуем признак пола, Tensorflow создаст 2 новых столбца, один для мужчин и один для женщин. Если пол равен мужскому, то новый столбец мужского пола будет равен 1, а женский — 0. Этот пример показан в таблице ниже:

rows sex after transformation male female
1 male => 1 0
2 male => 1 0
3 female =>

In tensorflow:

print_transformation(feature = “sex”, continuous = False, size = 2)
[[1. 0.]
[1. 0.]
[1. 0.]
…
[0. 1.]
[1. 0.]
[0. 1.]]

relationship = tf.feature_column.categorical_column_with_vocabulary_list(
‘relationship’, [
‘Husband’, ‘Not-in-family’, ‘Wife’, ‘Own-child’, ‘Unmarried’,
‘Other-relative’])

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

Однако более быстрый способ преобразования данных — использовать метод categorical_column_with_hash_bucket.
Изменение строковых переменных в разреженной матрице будет полезно.
Разреженная матрица — это матрица, состоящая в основном из нулей.
Метод заботится обо всем. Вам нужно только указать количество сегментов и ключевой столбец.
Количество сегментов — это максимальное количество групп, которые может создать Tensorflow.
Ключевой столбец — это просто имя столбца для преобразования.

В приведенном ниже коде вы создаете цикл по всем категориальным функциям

categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]

Шаг 3) Обучите классификатор
В настоящее время TensorFlow предоставляет оценщик для линейной регрессии и линейной классификации.

Линейная регрессия: LinearRegressor
Линейная классификация: LinearClassifier
Синтаксис линейного классификатора такой же, как и в учебнике по линейной регрессии, за исключением одного аргумента, n_class.
Вам нужно определить столбец функций, каталог модели и сравнить с линейным регрессором; у вас есть определить номер класса.
Для логит-регрессии количество классов равно 2.

Модель будет вычислять веса столбцов, содержащихся в Continuous_features и categorical_features.

model = tf.estimator.LinearClassifier(
n_classes = 2,
model_dir=”ongoing/train”,
feature_columns=categorical_features+ continuous_features)

Output

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {‘_model_dir’: ‘ongoing/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 0x181f24c898>, ‘_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}

Теперь, когда классификатор определен, вы можете создать входную функцию.
Метод такой же, как и в учебнике по линейному регрессору. Здесь вы используете размер пакета 128 и перемешиваете данные.

FEATURES = [‘age’,’workclass’, ‘fnlwgt’, ‘education’, ‘education_num’, ‘marital’, ‘occupation’, ‘relationship’, ‘race’, ‘sex’, ‘capital_gain’, ‘capital_loss’, ‘hours_week’, ‘native_country’]
LABEL= ‘label’
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)

Вы создаете функцию с аргументами, требуемыми для линейной оценки, т. е. количеством эпох, количеством пакетов, и перемешиваете набор данных или заметку.
Поскольку вы используете метод Pandas для передачи данных в модель, вам необходимо определить переменные X как фрейм данных pandas.
Обратите внимание, что вы перебираете все данные, хранящиеся в FEATURES.

Давайте обучим модель с помощью объекта model.train. Вы используете ранее определенную функцию, чтобы передать модели соответствующие значения.
Обратите внимание, что для размера пакета установлено значение 128, а для количества эпох — значение None. Модель будет обучена более тысячи шагов.

model.train(input_fn=get_input_fn(df_train,
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 ongoing/train/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 65.8282
INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)
INFO:tensorflow:global_step/sec: 118.386
INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)
INFO:tensorflow:global_step/sec: 110.542
INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)
INFO:tensorflow:global_step/sec: 199.03
INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)
INFO:tensorflow:global_step/sec: 167.488
INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)
INFO:tensorflow:global_step/sec: 220.155
INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)
INFO:tensorflow:global_step/sec: 199.016
INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)
INFO:tensorflow:global_step/sec: 197.531
INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)
INFO:tensorflow:global_step/sec: 208.479
INFO:tensorflow:loss = 22201.918, step = 901 (0.479 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train/model.ckpt.
INFO:tensorflow:Loss for final step: 5444.363.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181f223630>

Обратите внимание, что потери последовательно уменьшались в течение последних 100 шагов, т. е. с 901 до 1000.

Окончательный убыток после тысячи итераций — 5444. Вы можете оценить свою модель на тестовом наборе и посмотреть производительность.
Чтобы оценить производительность вашей модели, вам нужно использовать оценку объекта.
Вы загружаете модель тестовым набором и устанавливаете количество эпох равным 1, т. е. данные будут поступать в модель только один раз.

model.evaluate(input_fn=get_input_fn(df_test,
num_epochs=1,
n_batch = 128,
shuffle=False),
steps=1000)

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to “careful_interpolation” instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to “careful_interpolation” instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:22
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:23
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7615626, accuracy_baseline = 0.76377374, auc = 0.63300294, auc_precision_recall = 0.50891197, average_loss = 47.12155, global_step = 1000, label/mean = 0.23622628, loss = 5993.6406, precision = 0.49401596, prediction/mean = 0.18454961, recall = 0.38637546

{‘accuracy’: 0.7615626,
‘accuracy_baseline’: 0.76377374,
‘auc’: 0.63300294,
‘auc_precision_recall’: 0.50891197,
‘average_loss’: 47.12155,
‘global_step’: 1000,
‘label/mean’: 0.23622628,
‘loss’: 5993.6406,
‘precision’: 0.49401596,
‘prediction/mean’: 0.18454961,
‘recall’: 0.38637546}

TensorFlow возвращает все метрики, которые вы узнали в теоретической части. Неудивительно, что точность велика из-за несбалансированной метки.
На самом деле модель работает немного лучше, чем случайное предположение. Представьте, что модель предсказывает все домохозяйства с доходом ниже 50 тысяч,
тогда точность модели составляет 70 процентов. При более внимательном анализе вы можете увидеть, что предсказание и отзыв довольно низки.

Шаг 4) Улучшить модель
Теперь, когда у вас есть эталонная модель, вы можете попробовать ее улучшить, то есть повысить точность.
В предыдущем уроке вы узнали, как улучшить силу предсказания с помощью термина взаимодействия. В этом руководстве вы вернетесь к этой идее, добавив полиномиальный член к регрессии.

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

Добавить полиномиальный член
Превратите непрерывную переменную в категориальную переменную
Полиномиальный термин
На картинке ниже вы можете увидеть, что такое полиномиальная регрессия. Это уравнение с переменными X с разной степенью.
Полиномиальная регрессия второй степени имеет две переменные, X и X в квадрате. Третья степень имеет три переменные, X, X 2 и X 3

Что такое полиномиальная регрессия
Что такое полиномиальная регрессия

Ниже мы построили график с двумя переменными, X и Y. Очевидно, что зависимость не является линейной.
Если мы добавим линейную регрессию, мы увидим, что модель не может уловить закономерность (левое изображение).

def square_var(df_t, df_te, var_name = ‘age’):
df_t[‘new’] = df_t[var_name].pow(2)
df_te[‘new’] = df_te[var_name].pow(2)
return df_t, df_te

мы добавили пятичлен к регрессии (то есть y=x+x 2 +x 3 +x 4 +x 5 . Теперь модель намного лучше отражает закономерность. Это мощность полиномиальной регрессии.

Пример полиномиальной регрессии
Вернемся к нашему примеру. Возраст не находится в линейной зависимости от дохода. В раннем возрасте может быть фиксированный доход, близкий к нулю, потому что дети или молодые люди не работают. Затем она увеличивается в трудоспособном возрасте и уменьшается при выходе на пенсию. Обычно это перевернутая U-образная форма. Один из способов уловить эту закономерность — добавить к регрессии степень два.

Посмотрим, повысится ли точность.

Вам нужно добавить эту новую функцию в набор данных и в список непрерывных функций.

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

Функция имеет 3 аргумента:

df_t: определить тренировочный набор
df_te: определить набор тестов
var_name = ‘age’: Определите переменную для преобразования
Вы можете использовать объект pow(2) для возведения в квадрат переменной age. Обратите внимание, что новая переменная называется «новая».

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

df_train_new, df_test_new = square_var(df_train, df_test, var_name = ‘age’)

Квадратная переменная называется новой в наборе данных. Вам нужно добавить его в список непрерывных функций.

print(df_train_new.shape, df_test_new.shape)
(32561, 16) (16281, 16)

Квадратная переменная называется новой в наборе данных. Вам нужно добавить его в список непрерывных функций.

CONTI_FEATURES_NEW = [‘age’, ‘fnlwgt’,’capital_gain’, ‘education_num’, ‘capital_loss’, ‘hours_week’, ‘new’]
continuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]

Обратите внимание , что вы изменили каталог Graph. Вы не можете обучать разные модели в одном и том же каталоге. Это означает, что вам нужно изменить путь аргумента model_dir. Если вы этого не сделаете, TensorFlow выдаст ошибку.

model_1 = tf.estimator.LinearClassifier(
model_dir=”ongoing/train1″,
feature_columns=categorical_features+ continuous_features_new)
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {‘_model_dir’: ‘ongoing/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 0x1820f04b70>, ‘_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}
FEATURES_NEW = [‘age’,’workclass’, ‘fnlwgt’, ‘education’, ‘education_num’, ‘marital’, ‘occupation’, ‘relationship’, ‘race’, ‘sex’, ‘capital_gain’, ‘capital_loss’, ‘hours_week’, ‘native_country’, ‘new’]
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_NEW}),
y = pd.Series(data_set[LABEL].values),
batch_size=n_batch,
num_epochs=num_epochs,
shuffle=shuffle)

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

model_1.train(input_fn=get_input_fn(df_train,
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 ongoing/train1/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 81.487
INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)
INFO:tensorflow:global_step/sec: 111.169
INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)
INFO:tensorflow:global_step/sec: 128.91
INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)
INFO:tensorflow:global_step/sec: 132.546
INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)
INFO:tensorflow:global_step/sec: 162.194
INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)
INFO:tensorflow:global_step/sec: 204.852
INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)
INFO:tensorflow:global_step/sec: 188.923
INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)
INFO:tensorflow:global_step/sec: 192.041
INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)
INFO:tensorflow:global_step/sec: 197.025
INFO:tensorflow:loss = 3309.5786, step = 901 (0.507 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train1/model.ckpt.
INFO:tensorflow:Loss for final step: 28861.898.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1820f04c88>
model_1.evaluate(input_fn=get_input_fn(df_test_new,
num_epochs=1,
n_batch = 128,
shuffle=False),
steps=1000)
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to “careful_interpolation” instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to “careful_interpolation” instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:37
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:39
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7944229, accuracy_baseline = 0.76377374, auc = 0.6093755, auc_precision_recall = 0.54885805, average_loss = 111.0046, global_step = 1000, label/mean = 0.23622628, loss = 14119.265, precision = 0.6682401, prediction/mean = 0.09116262, recall = 0.2576703

{‘accuracy’: 0.7944229,
‘accuracy_baseline’: 0.76377374,
‘auc’: 0.6093755,
‘auc_precision_recall’: 0.54885805,
‘average_loss’: 111.0046,
‘global_step’: 1000,
‘label/mean’: 0.23622628,
‘loss’: 14119.265,
‘precision’: 0.6682401,
‘prediction/mean’: 0.09116262,
‘recall’: 0.2576703}

Квадрат переменной повысил точность с 0,76 до 0,79. Давайте посмотрим, сможете ли вы добиться большего успеха, объединив сегментацию и термин взаимодействия.

Бакетизация и взаимодействие
Как вы видели ранее, линейный классификатор не может правильно отразить модель возраст-доход. Это потому, что он изучает один вес для каждой функции. Чтобы упростить работу классификатора, вы можете разделить функцию на сегменты. Разделение преобразует числовую характеристику в несколько определенных характеристик в зависимости от диапазона, в который она попадает, и каждая из этих новых функций указывает, попадает ли возраст человека в этот диапазон.

Благодаря этим новым функциям линейная модель может фиксировать взаимосвязь, изучая разные веса для каждого сегмента.

В TensorFlow это делается с помощью Bucketized_column. Вам нужно добавить диапазон значений в границы.

age = tf.feature_column.numeric_column(‘age’)
age_buckets = tf.feature_column.bucketized_column(
age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])

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

Вы можете разбить возраст на другую характеристику, такую ​​как образование. То есть одни группы, вероятно, будут иметь высокий доход, а другие — низкий (вспомните аспиранта).

education_x_occupation = [tf.feature_column.crossed_column(
[‘education’, ‘occupation’], hash_bucket_size=1000)]
age_buckets_x_education_x_occupation = [tf.feature_column.crossed_column(
[age_buckets, ‘education’, ‘occupation’], hash_bucket_size=1000)]

Чтобы создать столбец кросс-функций, вы используете crossed_column с переменными для пересечения в скобках. hash_bucket_size указывает максимальные возможности пересечения. Чтобы создать взаимодействие между переменными (по крайней мере, одна переменная должна быть категориальной), вы можете использовать tf.feature_column.crossed_column. Чтобы использовать этот объект, вам нужно добавить в квадратные скобки переменную для взаимодействия и второй аргумент, размер корзины. Размер корзины — это максимально возможное количество групп в переменной. Здесь вы устанавливаете его на 1000, так как вы не знаете точное количество групп

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

base_columns = [
age_buckets,
]

model_imp = tf.estimator.LinearClassifier(
model_dir=”ongoing/train3″,
feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation)

Output

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {‘_model_dir’: ‘ongoing/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 0x1823021be0>, ‘_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}
FEATURES_imp = [‘age’,’workclass’, ‘education’, ‘education_num’, ‘marital’,
‘occupation’, ‘relationship’, ‘race’, ‘sex’, ‘native_country’, ‘new’]

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_imp}),
y = pd.Series(data_set[LABEL].values),
batch_size=n_batch,
num_epochs=num_epochs,
shuffle=shuffle)

Вы готовы оценить новую модель и посмотреть, улучшит ли она точность.

model_imp.train(input_fn=get_input_fn(df_train_new,
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 ongoing/train3/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 94.969
INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)
INFO:tensorflow:global_step/sec: 242.342
INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)
INFO:tensorflow:global_step/sec: 213.686
INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)
INFO:tensorflow:global_step/sec: 174.084
INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)
INFO:tensorflow:global_step/sec: 191.78
INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)
INFO:tensorflow:global_step/sec: 163.436
INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)
INFO:tensorflow:global_step/sec: 164.347
INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)
INFO:tensorflow:global_step/sec: 154.274
INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)
INFO:tensorflow:global_step/sec: 189.14
INFO:tensorflow:loss = 44.69645, step = 901 (0.531 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train3/model.ckpt.
INFO:tensorflow:Loss for final step: 44.18133.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1823021cf8>
model_imp.evaluate(input_fn=get_input_fn(df_test_new,
num_epochs=1,
n_batch = 128,
shuffle=False),
steps=1000)

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to “careful_interpolation” instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to “careful_interpolation” instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:52
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:54
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.8358209, accuracy_baseline = 0.76377374, auc = 0.88401634, auc_precision_recall = 0.69599575, average_loss = 0.35122654, global_step = 1000, label/mean = 0.23622628, loss = 44.67437, precision = 0.68986726, prediction/mean = 0.23320661, recall = 0.55408216

{‘accuracy’: 0.8358209,
‘accuracy_baseline’: 0.76377374,
‘auc’: 0.88401634,
‘auc_precision_recall’: 0.69599575,
‘average_loss’: 0.35122654,
‘global_step’: 1000,
‘label/mean’: 0.23622628,
‘loss’: 44.67437,
‘precision’: 0.68986726,
‘prediction/mean’: 0.23320661,
‘recall’: 0.55408216}

Новый уровень точности составляет 83,58 процента. Это на четыре процента выше, чем у предыдущей модели.

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

Шаг 5) Гиперпараметр: Лассо и Ридж
Ваша модель может страдать от переобучения или недообучения .

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

Чтобы предотвратить переоснащение, регуляризация дает вам возможность контролировать такую ​​сложность и делать ее более универсальной. Существует два метода регуляризации:

L1: лассо
L2: хребет
В TensorFlow вы можете добавить эти два гиперпараметра в оптимизатор. Например, чем выше гиперпараметр L2, вес имеет тенденцию быть очень низким и близким к нулю. Подогнанная линия будет очень плоской, а значение L2, близкое к нулю, означает, что веса близки к обычной линейной регрессии.

Вы можете сами попробовать разные значения гиперпараметров и посмотреть, сможете ли вы повысить уровень точности.

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

Посмотрим, как точность с шумихой

model_regu = tf.estimator.LinearClassifier(
model_dir=”ongoing/train4″, feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation,
optimizer=tf.train.FtrlOptimizer(
learning_rate=0.1,
l1_regularization_strength=0.9,
l2_regularization_strength=5))

OUPUT

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {‘_model_dir’: ‘ongoing/train4’, ‘_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 0x1820d9c128>, ‘_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}
model_regu.train(input_fn=get_input_fn(df_train_new,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)

OUPUT

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 ongoing/train4/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 77.4165
INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)
INFO:tensorflow:global_step/sec: 187.889
INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)
INFO:tensorflow:global_step/sec: 201.895
INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)
INFO:tensorflow:global_step/sec: 217.992
INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)
INFO:tensorflow:global_step/sec: 193.676
INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)
INFO:tensorflow:global_step/sec: 202.195
INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)
INFO:tensorflow:global_step/sec: 216.756
INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)
INFO:tensorflow:global_step/sec: 240.215
INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)
INFO:tensorflow:global_step/sec: 220.336
INFO:tensorflow:loss = 46.938225, step = 901 (0.456 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train4/model.ckpt.
INFO:tensorflow:Loss for final step: 43.4942.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181ff39e48>
model_regu.evaluate(input_fn=get_input_fn(df_test_new,
num_epochs=1,
n_batch = 128,
shuffle=False),
steps=1000)

Output

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to “careful_interpolation” instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to “careful_interpolation” instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:29:07
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:29:09
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.83833915, accuracy_baseline = 0.76377374, auc = 0.8869794, auc_precision_recall = 0.7014905, average_loss = 0.34691378, global_step = 1000, label/mean = 0.23622628, loss = 44.12581, precision = 0.69720596, prediction/mean = 0.23662092, recall = 0.5579823

{‘accuracy’: 0.83833915,
‘accuracy_baseline’: 0.76377374,
‘auc’: 0.8869794,
‘auc_precision_recall’: 0.7014905,
‘average_loss’: 0.34691378,
‘global_step’: 1000,
‘label/mean’: 0.23622628,
‘loss’: 44.12581,
‘precision’: 0.69720596,
‘prediction/mean’: 0.23662092,
‘recall’: 0.5579823}

С помощью этого гиперпараметра вы немного увеличиваете показатели точности. В следующем уроке вы узнаете, как улучшить линейный классификатор с помощью метода ядра.

Резюме
Для обучения модели необходимо:

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

Колонки функций. Если непрерывно: tf.feature_column.numeric_column(). Вы можете заполнить список пониманием списка python
Оценщик: tf.estimator.LinearClassifier(feature_columns, model_dir, n_classes = 2)
Функция для импорта данных, размера пакета и эпохи: input_fn()
После этого вы готовы тренироваться, оценивать и делать прогнозы с помощью train(), Assessment() и Predict().

Статья является переводом www.guru99.com

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

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

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

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

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

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

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

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

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

С:

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

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

•  = 3,8
•  = 2,78

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

у = 3,8 + 2,78х

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

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

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

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

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

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

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

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

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

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

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

Где:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• С пандами
• С Нампи
• Только ТФ

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

Вы узнаете, как использовать высокоуровневый API для построения, обучения и оценки модели линейной регрессии TensorFlow. Если вы использовали низкоуровневый 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, имена=СТОЛБЦЫ)

test_set = pd.read_csv(“E:/boston_test.csv”, skipinitialspace=True, skiprows=1, имена=СТОЛБЦЫ)

Prediction_set = pd.read_csv(“E:/boston_predict.csv”, skipinitialspace=True, skiprows=1, имена=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().

На предыдущем шаге вы определяете список функций, которые хотите включить в модель. Теперь вы можете использовать этот список для преобразования их в числовые данные. Если вы хотите исключить функции из своей модели, не стесняйтесь удалять одну или несколько переменных в списке FEATURES, прежде чем создавать 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 для задачи регрессии TensorFlow:

• регрессор
  • DNNРегрессор
  • Линейный регрессор
  • DNNLineaCombinedRegressor
• Классификатор
  • DNNКлассификатор
  • Линейный классификатор
  • DNNLineaCombinedClassifier

В этом уроке вы будете использовать линейный регрессор. Чтобы получить доступ к этой функции, вам нужно использовать 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': <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 параметров:

• х: данные функции
• у: данные метки
• размер_пакета: пакет. По умолчанию 128
• num_epoch: количество эпох, по умолчанию 1
• shuffle: перемешивать или нет данные. По умолчанию Нет

Вам нужно много раз передать модель, поэтому вы определяете функцию для повторения этого процесса. все это функция 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 рядов

Поэтому проще установить число эпох равным нулю и определить количество итераций, как показано в приведенном ниже примере классификации 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 = 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) Сделайте прогноз

Наконец, вы можете использовать прогноз 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-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)]

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

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

тупое решение

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

training_set_n = pd.read_csv(“E:/boston_train.csv”).values

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

Prediction_set_n = pd.read_csv(“E:/boston_predict.csv”).values

Шаг 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}

Вы можете использовать numpy estimapor для подачи данных в модель, а затем обучить модель. Обратите внимание, что мы определяем функцию 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. Этот метод немного сложнее, чем предыдущий.

Обратите внимание, что если вы используете блокнот 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 функций, поэтому вам нужно указать значение для каждой. Модель даст прогноз для каждого из них.

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

Вам нужно написать новую функцию 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 для оценки TensorFlow линейной регрессии. Вам необходимо определить:

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

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

Статья является переводом guru99.com