Theano - Краткое руководство

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

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

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

Theano был написан в лаборатории LISA с целью обеспечить быструю разработку эффективных алгоритмов машинного обучения. Он выпущен под лицензией BSD.

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

Theano можно установить в Windows, MacOS и Linux. Установка во всех случаях тривиальна. Перед установкой Theano необходимо установить его зависимости. Ниже приведен список зависимостей -

• Python
• NumPy - обязательно
• SciPy - требуется только для разреженной матрицы и специальных функций
• BLAS - предоставляет стандартные строительные блоки для выполнения основных векторных и матричных операций.

Дополнительные пакеты, которые вы можете выбрать для установки в зависимости от ваших потребностей, следующие:

• нос: Чтобы запустить набор тестов Теано
• Sphinx - Для строительной документации
• Graphiz и pydot - для обработки графики и изображений
• Драйверы NVIDIA CUDA - необходимы для генерации / выполнения кода графического процессора
• libgpuarray - требуется для генерации кода GPU / CPU на устройствах CUDA и OpenCL

Мы обсудим шаги по установке Theano в MacOS.

Установка MacOS

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

$ pip install Theano
$ pip install numpy
$ pip install scipy
$ pip install pydot

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

$ xcode-select --install

Вы увидите следующий экран. Нажми наInstall кнопку для установки инструмента.

При успешной установке вы увидите сообщение об успешном выполнении на консоли.

Тестирование установки

После успешного завершения установки откройте новый блокнот в Anaconda Jupyter. В ячейке кода введите следующий скрипт Python -

пример

import theano
from theano import tensor
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
d = f(1.5, 2.5)
print (d)

Вывод

Запустите скрипт, и вы должны увидеть следующий результат -

4.0

Снимок экрана с казнью показан ниже для вашего быстрого ознакомления -

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

Что такое Теано?

Теперь, когда вы успешно установили Theano, давайте сначала попробуем понять, что такое Theano? Theano - это библиотека Python. Он позволяет определять, оптимизировать и оценивать математические выражения, особенно те, которые используются при разработке модели машинного обучения. Сам Theano не содержит заранее определенных моделей машинного обучения; это просто способствует его развитию. Это особенно полезно при работе с многомерными массивами. Он легко интегрируется с NumPy, который является фундаментальным и широко используемым пакетом для научных вычислений на Python.

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

Сначала Theano строит весь вычислительный график для вашей модели. Затем он компилирует его в высокоэффективный код, применяя к графу несколько методов оптимизации. Скомпилированный код вводится в среду выполнения Theano специальной операцией, называемойfunctionдоступно в Теано. Мы выполняем этоfunctionмногократно обучать нейронную сеть. Время обучения существенно сокращается по сравнению с использованием чистого кода Python или даже полной реализации C.

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

Давайте начнем наше путешествие по Theano с определения и оценки тривиального выражения в Theano. Рассмотрим следующее тривиальное выражение, которое складывает два скаляра:

c = a + b

где a, b переменные и cэто результат выражения. В Theano сложно определить и оценить даже это тривиальное выражение.

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

Импорт Theano

Во-первых, нам нужно импортировать библиотеку Theano в нашу программу, что мы делаем с помощью следующего оператора:

from theano import *

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

Объявление переменных

Затем мы объявим переменную с именем a используя следующее утверждение -

a = tensor.dscalar()

В dscalarобъявляет десятичную скалярную переменную. Выполнение вышеуказанного оператора создает переменную с именемaв вашем программном коде. Таким же образом мы создадим переменнуюb используя следующее утверждение -

b = tensor.dscalar()

Определение выражения

Затем мы определим наше выражение, которое работает с этими двумя переменными a и b.

c = a + b

В Theano выполнение вышеуказанного оператора не выполняет скалярное сложение двух переменных. a и b.

Определение функции Theano

Чтобы оценить приведенное выше выражение, нам нужно определить функцию в Theano следующим образом:

f = theano.function([a,b], c)

Функция functionпринимает два аргумента, первый аргумент является входом для функции, а второй - ее выходом. В приведенном выше объявлении говорится, что первый аргумент имеет тип array, состоящий из двух элементовa и b. На выходе получается скалярная единица, называемаяc. На эту функцию будет ссылаться имя переменнойf в нашем дальнейшем коде.

Вызов функции Theano

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

d = f(3.5, 5.5)

Входом в функцию является массив, состоящий из двух скаляров: 3.5 и 5.5. Результат выполнения присваивается скалярной переменнойd. Чтобы распечатать содержимоеd, мы будем использовать print заявление -

print (d)

Выполнение приведет к значению d для печати на консоли, в данном случае это 9.0.

Полный список программ

Полный список программ приведен здесь для вашего быстрого ознакомления -

from theano import *
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
d = f(3.5, 5.5)
print (d)

Выполните приведенный выше код, и вы увидите результат 9.0. Снимок экрана показан здесь -

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

Мы вычислим скалярное произведение двух матриц. Первая матрица имеет размер 2 x 3, а вторая - размер 3 x 2. Матрицы, которые мы использовали в качестве входных данных, и их продукт выражены здесь -

$$ \ begin {bmatrix} 0 & -1 & 2 \\ 4 & 11 & 2 \ end {bmatrix} \: \ begin {bmatrix} 3 & -1 \\ 1 & 2 \\ 35 & 20 \ end {bmatrix} = \ begin {bmatrix} 11 & 0 \\ 35 & 20 \ end {bmatrix} $$

Объявление переменных

Чтобы написать выражение Theano для вышеупомянутого, мы сначала объявляем две переменные для представления наших матриц следующим образом:

a = tensor.dmatrix()
b = tensor.dmatrix()

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

Определение выражения

Для вычисления скалярного произведения мы использовали встроенную функцию под названием dot следующим образом -

c = tensor.dot(a,b)

Результат умножения присваивается матричной переменной, называемой c.

Определение функции Theano

Затем мы определяем функцию, как в предыдущем примере, для оценки выражения.

f = theano.function([a,b], c)

Обратите внимание, что входными данными функции являются две переменные a и b матричного типа. Выход функции присваивается переменнойc которая автоматически будет матричного типа.

Вызов функции Theano

Теперь мы вызываем функцию, используя следующий оператор -

d = f([[0, -1, 2], [4, 11, 2]], [[3, -1],[1,2], [6,1]])

Две переменные в приведенном выше утверждении - это массивы NumPy. Вы можете явно определить массивы NumPy, как показано здесь -

f(numpy.array([[0, -1, 2], [4, 11, 2]]),
numpy.array([[3, -1],[1,2], [6,1]]))

После d вычисляется, печатаем его значение -

print (d)

На выходе вы увидите следующий вывод -

[[11. 0.]
[25. 20.]]

Полный список программ

The complete program listing is given here:
from theano import *
a = tensor.dmatrix()
b = tensor.dmatrix()
c = tensor.dot(a,b)
f = theano.function([a,b], c)
d = f([[0, -1, 2],[4, 11, 2]], [[3, -1],[1,2],[6,1]])
print (d)

Скриншот выполнения программы показан здесь -

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

Символьный граф для скалярного сложения

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

theano.printing.pydotprint(f, outfile="scalar_addition.png", var_with_name_simple=True)

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

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

from theano import *
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
theano.printing.pydotprint(f, outfile="scalar_addition.png", var_with_name_simple=True)

Символьный график для матричного множителя

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

from theano import *
a = tensor.dmatrix()
b = tensor.dmatrix()
c = tensor.dot(a,b)
f = theano.function([a,b], c)
theano.printing.pydotprint(f, outfile="matrix_dot_product.png", var_with_name_simple=True)

Сгенерированный график показан здесь -

Сложные графы

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

Чтобы понять работу Theano, важно сначала узнать значение этих вычислительных графов. С таким пониманием мы узнаем важность Теано.

Почему Теано?

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

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

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

Тип данных	Тип Theano
Байт	bscalar, bvector, bmatrix, brow, bcol, btensor3, btensor4, btensor5, btensor6, btensor7
16-битные целые числа	wscalar, wvector, wmatrix, wrow, wcol, wtensor3, wtensor4, wtensor5, wtensor6, wtensor7
32-битные целые числа	iscalar, ivector, imatrix, irow, icol, itensor3, itensor4, itensor5, itensor6, itensor7
64-битные целые числа	lscalar, lvector, lmatrix, lrow, lcol, ltensor3, ltensor4, ltensor5, ltensor6, ltensor7
плавать	fscalar, fvector, fmatrix, frow, fcol, ftensor3, ftensor4, ftensor5, ftensor6, ftensor7
двойной	dscalar, dvector, dmatrix, drow, dcol, dtensor3, dtensor4, dtensor5, dtensor6, dtensor7
сложный	cscalar, cvector, cmatrix, crow, ccol, ctensor3, ctensor4, ctensor5, ctensor6, ctensor7

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

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

Скалярный

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

Синтаксис

x = theano.tensor.scalar ('x')
x = 5.0
print (x)

Вывод

5.0

Одномерный массив

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

пример

f = theano.tensor.vector
f = (2.0, 5.0, 3.0)
print (f)f = theano.tensor.vector
f = (2.0, 5.0, 3.0)
print (f)
print (f[0])
print (f[2])

Вывод

(2.0, 5.0, 3.0)
2.0
3.0

Если вы сделаете f[3] он сгенерирует ошибку индекса вне диапазона, как показано здесь -

print f([3])

Вывод

IndexError                          Traceback (most recent call last)
<ipython-input-13-2a9c2a643c3a> in <module>
   4 print (f[0])
   5 print (f[2])
----> 6 print (f[3])
IndexError: tuple index out of range

Двумерный массив

Чтобы объявить двумерный массив, вы должны использовать следующий фрагмент кода -

пример

m = theano.tensor.matrix
m = ([2,3], [4,5], [2,4])
print (m[0])
print (m[1][0])

Вывод

[2, 3]
4

5-мерный массив

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

пример

m5 = theano.tensor.tensor5
m5 = ([0,1,2,3,4], [5,6,7,8,9], [10,11,12,13,14])
print (m5[1])
print (m5[2][3])

Вывод

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

Вы можете объявить трехмерный массив, используя тип данных tensor3 на месте tensor5, 4-мерный массив, использующий тип данных tensor4и так далее до tensor7.

Множественные конструкторы

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

Синтаксис

from theano.tensor import * x, y, z = dmatrices('x', 'y', 'z') 
x = ([1,2],[3,4],[5,6]) 
y = ([7,8],[9,10],[11,12]) 
z = ([13,14],[15,16],[17,18]) 
print (x[2]) 
print (y[1]) 
print (z[0])

Вывод

[5, 6] 
[9, 10] 
[13, 14]

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

x = theano.tensor.fvector('x')

В этом заявлении мы создали переменную xвектора типа, содержащего 32-битные числа с плавающей запятой. Мы также называем егоx. Имена обычно полезны для отладки.

Чтобы объявить вектор 32-битных целых чисел, вы должны использовать следующий синтаксис:

i32 = theano.tensor.ivector

Здесь мы не указываем имя переменной.

Чтобы объявить трехмерный вектор, состоящий из 64-битных чисел с плавающей запятой, вы должны использовать следующее объявление:

f64 = theano.tensor.dtensor3

Различные типы конструкторов вместе с их типами данных перечислены в таблице ниже -

Конструктор	Тип данных	Габаритные размеры
вектор	float32	1
ивектор	int32	1
fscalar	float32	0
матрица	float32	2
ftensor3	float32	3
dtensor3	float64	3

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

x = theano.tensor.vector ('x', dtype=int32)

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

Много раз вам нужно было бы создать переменные, которые используются разными функциями, а также между несколькими вызовами одной и той же функции. Приведем пример: при обучении нейронной сети вы создаете вектор весов для присвоения веса каждой рассматриваемой функции. Этот вектор изменяется на каждой итерации во время обучения сети. Таким образом, он должен быть глобально доступен для нескольких вызовов одной и той же функции. Поэтому мы создаем для этой цели общую переменную. Как правило, Theano перемещает такие общие переменные в GPU, если таковая имеется. Это ускоряет вычисления.

Синтаксис

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

import numpy
W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')

пример

Здесь создается массив NumPy, состоящий из четырех чисел с плавающей запятой. Установить / получитьW значение, вы должны использовать следующий фрагмент кода -

import numpy
W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')
print ("Original: ", W.get_value())
print ("Setting new values (0.5, 0.2, 0.4, 0.2)")
W.set_value([0.5, 0.2, 0.4, 0.2])
print ("After modifications:", W.get_value())

Вывод

Original: [0.1 0.25 0.15 0.3 ]
Setting new values (0.5, 0.2, 0.4, 0.2)
After modifications: [0.5 0.2 0.4 0.2]

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

Эффективный скомпилированный код теперь предоставляется в качестве входных данных для Theano. function. Когда вы выполняете Theanofunction, он присваивает результат вычисления указанным нами переменным. Тип оптимизации может быть указан как FAST_COMPILE или FAST_RUN. Это указано в переменной среды THEANO_FLAGS.

Теано function объявляется с использованием следующего синтаксиса -

f = theano.function ([x], y)

Первый параметр [x] это список входных переменных и второй параметр y это список выходных переменных.

Разобравшись с основами Theano, давайте начнем кодирование Theano с тривиального примера.

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

Постановка задачи

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

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

sum = f1 * w1 + f2 * w2 + f3 * w3 + f4 * w4

где f1, f2, ... - значения характеристик и w1, w2, ... - веса.

Позвольте мне проанализировать пример, чтобы лучше понять постановку проблемы. Мы примем начальное значение 1.0 для каждой функции и примем, что w1 равно0.1, w2 равно 0.25, w3 равно 0.15, и w4 равно 0.3. Определенной логики в присвоении значений весов нет, это просто наша интуиция. Таким образом, начальная сумма выглядит следующим образом -

sum = 1.0 * 0.1 + 1.0 * 0.25 + 1.0 * 0.15 + 1.0 * 0.3

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

Посмотрим, как вся эта логика реализована в Theano.

Объявление переменных

Сначала мы объявляем наш входной вектор x следующим образом:

x = tensor.fvector('x')

где x - одномерный массив значений с плавающей запятой.

Определим скаляр target переменная, как указано ниже -

target = tensor.fscalar('target')

Далее мы создаем тензор весов W с начальными значениями, как обсуждалось выше -

W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')

Определение выражения Theano

Теперь мы вычисляем результат, используя следующее выражение -

y = (x * W).sum()

Обратите внимание, что в приведенном выше заявлении x и W- векторы, а не простые скалярные переменные. Теперь мы вычисляем ошибку (стоимость) с помощью следующего выражения -

cost = tensor.sqr(target - y)

Стоимость - это разница между целевым значением и текущим выходом в квадрате.

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

gradients = tensor.grad(cost, [W])

Теперь мы обновляем weights вектор, взяв скорость обучения 0.1 следующим образом -

W_updated = W - (0.1 * gradients[0])

Затем нам нужно обновить наш вектор весов, используя указанные выше значения. Мы делаем это в следующем заявлении -

updates = [(W, W_updated)]

Определение / вызов функции Theano

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

f = function([x, target], y, updates=updates)

Чтобы вызвать указанную выше функцию определенное количество раз, мы создаем for цикл следующим образом -

for i in range(10):
output = f([1.0, 1.0, 1.0, 1.0], 100.0)

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

print ("iteration: ", i)
print ("Modified Weights: ", W.get_value())
print ("Output: ", output)

Полный список программ

Полный список программ воспроизводится здесь для вашего быстрого ознакомления -

from theano import *
import numpy

x = tensor.fvector('x')
target = tensor.fscalar('target')

W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')
print ("Weights: ", W.get_value())

y = (x * W).sum()
cost = tensor.sqr(target - y)
gradients = tensor.grad(cost, [W])
W_updated = W - (0.1 * gradients[0])
updates = [(W, W_updated)]

f = function([x, target], y, updates=updates)
for i in range(10):
   output = f([1.0, 1.0, 1.0, 1.0], 100.0)
   print ("iteration: ", i)
   print ("Modified Weights: ", W.get_value())
   print ("Output: ", output)

Когда вы запустите программу, вы увидите следующий вывод -

Weights: [0.1 0.25 0.15 0.3 ]
iteration: 0
Modified Weights: [19.94 20.09 19.99 20.14]
Output: 0.8
iteration: 1
Modified Weights: [23.908 24.058 23.958 24.108]
Output: 80.16000000000001
iteration: 2
Modified Weights: [24.7016 24.8516 24.7516 24.9016]
Output: 96.03200000000001
iteration: 3
Modified Weights: [24.86032 25.01032 24.91032 25.06032]
Output: 99.2064
iteration: 4
Modified Weights: [24.892064 25.042064 24.942064 25.092064]
Output: 99.84128
iteration: 5
Modified Weights: [24.8984128 25.0484128 24.9484128 25.0984128]
Output: 99.968256
iteration: 6
Modified Weights: [24.89968256 25.04968256 24.94968256 25.09968256]
Output: 99.9936512
iteration: 7
Modified Weights: [24.89993651 25.04993651 24.94993651 25.09993651]
Output: 99.99873024
iteration: 8
Modified Weights: [24.8999873 25.0499873 24.9499873 25.0999873]
Output: 99.99974604799999
iteration: 9
Modified Weights: [24.89999746 25.04999746 24.94999746 25.09999746]
Output: 99.99994920960002

Обратите внимание, что после четырех итераций на выходе будет 99.96 и после пяти итераций это 99.99, что близко к желаемой цели 100.0.

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

iteration: 5
Modified Weights: [24.8984128 25.0484128 24.9484128 25.0984128]

Теперь вы можете использовать эти значения в своей сети для развертывания модели.

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

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