Tensorflow, Python, Visual Studio. Quick start

Автор: | 24.10.2019

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

Введение

TensorFlow – популярнейший инструмент для машинного обучения нейросетей.

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

Ниже рассмотрены возможности пакета TensorFlow на  на примерах задач линейной регрессии. 

Существует два типа контролируемых алгоритмов машинного обучения: регрессия и классификация. Первый прогнозирует непрерывные выходные значения, а второй — дискретные выходные. Например, прогнозирование цены дома в долларах является проблемой регрессии, тогда как прогнозирование того, является ли опухоль злокачественной или доброкачественной, является проблемой классификации (подробнее см. A beginner’s guide to Linear Regression in Python with Scikit-Learn).

Создание проекта и установка пакетов

Если еще не установили поддержку Python в Visual Studio, то сделайте это (см. Инсталляция Python в Visual Studio).

Запустите Visual Studio и создайте проект приложения (File>New>Project>Python>Python Application).

Для тестирования системы вставьте код в файл с расширением .py и запустите приложение:

# Import tensorflow`
import tensorflow as tf

# Initialize two constants
x1 = tf.constant([1,2,3,4])
x2 = tf.constant([5,6,7,8])

# Multiply
result = tf.multiply(x1, x2)

# Print the result
print(result)

Если появляются ошибки, то система подскажет,  какой пакет еще не установлен. В коде используется пакет tensorflow. Пакеты добавляются непосредственно из проекта (см. Создание нейронной сети в Visual Studio).

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

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

Значения на входе связаны со значениями на выходе выражением:

F = 1.8* C + 32

где С — градусы Цельсия (входные значения), F — Фаренгейта (выходные значения).

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

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

from __future__ import absolute_import, division, print_function, unicode_literals
import tensorflow as tf
import logging
logging.getLogger("tensorflow").setLevel(logging.ERROR)
import numpy as np
import matplotlib.pyplot as plt

celsius_q = np.array([-40, -10, 0, 8, 15, 22], dtype=float)
fahrenheit_a = np.array([-40, 14, 32, 46, 59, 72], dtype=float)

for i,c in enumerate(celsius_q):
 print("{} градусов Цельсия = {} градусов Фаренгейта".format(c, fahrenheit_a[i]))

l0 = tf.keras.layers.Dense(units=1, input_shape=[1])

model = tf.keras.Sequential([l0])

model.compile(loss='mean_squared_error',
 optimizer=tf.keras.optimizers.Adam(0.1))
history = model.fit(celsius_q, fahrenheit_a, epochs=500, verbose=False)
print("Завершили тренировку модели")

plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.plot(history.history['loss'])
plt.show()

print(model.predict([38.0]))

Приложение запускается с tensorflow (2.0.0). В случае, если установлена более ранняя версия пакета, например, tensorflow (1.2.0), необходимо взамен нее инсталлировать tensorflow (2.0.0).

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

 

Число на выходе (97. 64668) было получено по числу на входе (38).

Расхождение с точным результатом (F = 1.8* 38 + 32  =100.4) составило около 3%.

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

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

Ниже приводится код к этой программе. Подробное описание кода см. в первоисточнике.

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np

# number of training examples
n_examples = 1000 
# number of steps we are going to train for
training_steps = 10000 
# after multiples of this display the loss
display_step = 10 
# multipliying factor on gradient
learning_rate = 0.001 
# gradient and y intercept of our line, edit these for a different linear problem
m, c = 6, -5

# A dataset of points around mx + c
def train_data(n, m, c):
 x = tf.random.normal([n]) # n values taken from a normal distribution, mean = 0, SD =1
 noise = tf.random.normal([n])# n values taken from a normal distribution, mean = 0, SD =1
 y = m*x + c + noise # our scatter plot
 return x, y

# Start with random values for W and B on the same batch of data
x, y = train_data(n_examples,m,c) # our training values x and y
plt.scatter(x,y)
plt.xlabel("x")
plt.ylabel("y")
plt.title("Figure 1: Training Data")

def prediction(x, weight, bias):
 # our predicted (learned) m and c, expression is like y=m*x + c
 return weight*x + bias
 
 
# A loss function using mean-squared error
def loss(x, y, weights, biases):
 # how 'wrong' our predicted (learned) y is
 error = prediction(x, weights, biases) - y 
 
 squared_error = tf.square(error)
 
 # overall mean of squared error
 return tf.reduce_mean(input_tensor=squared_error)
 
 
# Find the derivative of loss with respect to weight and bias
def grad(x, y, weights, biases):
 # magical feature of tensorflow to calculate gradient for backpropagation
 with tf.GradientTape() as tape:
  loss_ = loss(x, y, weights, biases)
 
 # direction and value of the gradient of our loss w.r.t weight and bias
 return tape.gradient(loss_, [weights, biases])

W = tf.Variable(np.random.randn()) # initial, random, value for predicted weight (m)
B = tf.Variable(np.random.randn()) # initial, random, value for predicted bias (c)
print("Initial loss: {:.3f}".format(loss(x, y, W, B)))

for step in range(training_steps): #iterate for each training step
 # direction (sign) and value of the gradient of our loss w.r.t weight and bias
 deltaW, deltaB = grad(x, y, W, B) 
 
 change_W = deltaW * learning_rate # adjustment amount for weight
 change_B = deltaB * learning_rate # adjustment amount for bias
 
 W.assign_sub(change_W) # subract change_W from W
 B.assign_sub(change_B) # subract change_B from B
 
 if step==0 or step % display_step == 0:
 # print(deltaW.numpy(), deltaB.numpy()) # uncomment if you want to see the gradients
  print("Loss at step {:02d}: {:.6f}".format(step, loss(x, y, W, B)))

print("Final loss: {:.3f}".format(loss(x, y, W, B)))
print("W = {}, B = {}".format(W.numpy(), B.numpy()))
print("Compared with m = {:.1f}, c = {:.1f}".format(m, c)," of the original line")
xs = np.linspace(-3, 4, 50)
ys = W.numpy()*xs + B.numpy()
plt.scatter(xs,ys)
plt.xlabel("x")
plt.ylabel("y")
plt.title("Figure 2: Line of Best Fit")
plt.show()

 

Полезные ссылки:

 

Автор: Николай Свирневский

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *