Lasagne python: Lasagne/Lasagne: Lightweight library to build and train neural networks in Theano

Содержание

Библиотеки для глубокого обучения Theano/Lasagne / Блог компании Open Data Science / Хабр

Привет, Хабр!

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

Я открою этот цикл статьёй о Theano — библиотеке, которая используется для разработки систем машинного обучения как сама по себе, так и в качестве вычислительного бекэнда для более высокоуровневых библиотек, например, Lasagne, Keras или Blocks.

Theano разрабатывается с 2007 года главным образом группой MILA из Университета Монреаля и названа в честь древнегреческой женщины-философа и математика Феано (предположительно изображена на картинке). Основными принципами являются: интеграция с numpy, прозрачное использование различных вычислительных устройств (главным образом GPU), динамическая генерация оптимизированного С-кода.

Будем придерживаться следующего плана:

Предисловие или лирическое отступление о библиотеках для глубокого обучения

Введение
- Установка
- Настройка

Основы
- Первые шаги
- Переменные и функции
- Разделяемые переменные и еще о функциях
- Отладка

Машинное обучение на Theano
- Логистическая регрессия
- SVM
- Нелинейные признаки

Lasagne
- Многослойный перцептрон

Заключение

Код с примерами из этого поста можно найти тут.

Предисловие или лирическое отступление о библиотеках для глубокого обучения

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

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

Вот так оно выглядело бы в императивном изложении на языке python:

    a = np.ones(10)
    b = np.ones(10) * 2
    c = b * a
    d = c + 1

Интерпретатор исполняет код построчно, сохраняя результаты в переменных a, b, c и d.

Та же программа в символьной парадигме выглядела бы так:

    A = Variable('A')
    B = Variable('B')
    C = B * A
    D = C + Constant(1)
    # компиляция функции
    f = compile(D)
    # исполнение
    d = f(A=np.ones(10), B=np.ones(10)*2)

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

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

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

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

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

Но довольно теории, давайте разбираться с Theano на примерах.

Установка

Для установки нам понадобятся: python версии старше 2.6 или 3.3 (лучше dev-версию), компилятор С++ (g++ для Linux или Windows, clang для MacOS), библиотека примитивов линейной алгебры (например ATLAS, OpenBLAS, Intel MKL), NumPy и SciPy.

Для выполнения вычислений на GPU понадобится CUDA, а ряд операций, встречающихся в нейронных сетях, можно ускорить с помощью сuDNN. Начиная с версии 0.8.0, разработчики Theano рекомендуют использовать libgpuarray, что также даёт возможность использовать несколько GPU.

Когда все зависимости установлены, можно установить Theano через pip:

# последний релиз
pip install Theano
# последняя версия из репозитория
pip install --upgrade https://github. com/Theano/Theano/archive/master.zip

Настройка

Theano можно настроить тремя способами:

Выставив атрибуты объекта theano.config в нужное значение

Через переменную окружения THEANO_FLAGS

Через конфигурационный файл $HOME/.theanorc (или $HOME/.theanorc.txt под Windows)

Я обычно использую примерно такой конфигурационный файл:

[global]
    device = gpu # выбирает устройство, на котором будет выполняться наш код - GPU или CPU
    floatX = float32
    optimizer_including=cudnn
    allow_gc = False # быстрее, но использует больше памяти
    #exception_verbosity=high
    #optimizer = None  # полезно при отладке
    #profile = True
    #profile_memory = True
config.dnn.conv.algo_fwd = time_once # эти две опции зачастую приводят к ускорению свёрток
config.dnn.conv.algo_bwd = time_once
[lib]
Cnmem = 0.95 # позволяет включить CNMeM (https://github. com/NVIDIA/cnmem) - менеджер CUDA-памяти

Подробнее о конфигурации можно узнать в документации.

Основы

Первые шаги

Теперь, когда всё установлено и настроено, давайте попробуем написать немного кода, например, вычислим значение многочлена в точке 10:

import theano 
import theano.tensor as T

# объявим theano-переменную
a = T.lscalar()
# определим выражение
expression = 1 + 2 * a + a ** 2
# скомпилируем theano-функцию
f = theano.function(
    inputs=[a],        # аргументы
    outputs=expression  # результат
)
# запустим вычисление
f(10)
>>> array(121)

Здесь мы совершили 4 вещи: определили скалярную переменную а типа long, создали выражение, содержащее наш многочлен, определили и скомпилировали функцию f, а также выполнили её, передав на вход число 10.

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

a = T.lvector()
expression = 1 + 2 * a + a ** 2
f = theano.function(
    inputs=[a],
    outputs=expression
)
arg = arange(-10, 10)
res = f(arg)
plot(arg, res, c='m', linewidth=3.)

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

UPD: Не секрет, что аппарат линейной алгебры повсеместно используется в машинном обучении: примеры описываются векторами признаков, параметры модели записывают в виде матриц, изображения представляют в виде 3х-мерных тензоров. Скалярные величины, векторы и матрицы можно рассматривать как частный случай тензоров, поэтому именно так мы в дальнейшем будем называть эти объекты линейной алгебры. Под тензором будем понимать N-мерные массивы чисел.

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

При несовпадении типов Theano выбросит исключение. Исправить это, кстати как и поменять многое другое в работе функций, можно, передав конструктору аргумент allow_input_downcast=True:

x = T.dmatrix('x')
v = T.fvector('v')

z = v + x

f = theano.function(
    inputs=[x, v],
    outputs=z,
    allow_input_downcast=True
)
f_fail = theano.function(
    inputs=[x, v],
    outputs=z
)
print(f(ones((3, 4), dtype=float64), ones((4,), dtype=float64))
>>> [[ 2.  2.  2.  2.]
>>>  [ 2.  2.  2.  2.]
>>>  [ 2.  2.  2.  2.]]
print(f_fail(ones((3, 4), dtype=float64), ones((4,), dtype=float64))
>>> ---------------------------------------------------------------------------
>>> TypeError                                 Traceback (most recent call last)

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

x = T. lscalar('x')
y = T.lscalar('y')

square = T.square(x + y)
sqrt = T.sqrt(x + y)

f = theano.function(
    inputs=[x, y],
    outputs=[square, sqrt]
)
print(f(5, 4))
>>> [array(81), array(3.0)]
print(f(2, 2))
>>> [array(16), array(2.0)]

Для обмена состояниями между функциями используются специальные shared переменные:

state = theano.shared(0)
i = T.iscalar('i')
inc = theano.function([i],
                      state,
                      # обновим разделяемую переменную
                      updates=[(state, state+i)])
dec = theano.function([i],
                      state,
                      updates=[(state, state-i)])

# разделяемые переменные могут менять значения сразу нескольких функций
print(state.get_value())
inc(1)
inc(1)
inc(1)
print(state.get_value())
dec(2)
print(state.get_value())
>>> 0
>>> 3
>>> 1

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

state. set_value(-15)
print(state.get_value())
>>> -15

Значения в shared переменных можно «подставлять» в тензорные переменные:

x = T.lscalar('x')
y = T.lscalar('y')
i = T.lscalar('i')

expression = (x - y) ** 2

state = theano.shared(0)

f = theano.function(
    inputs=[x, i],
    outputs=expression,
    updates=[(state, state+i)],
    # подставим значение переменной state в граф вместо y
    givens={
        y : state
    }
)
print(f(5, 1))
>>> 25
print(f(2, 1))
>>> 1

Отладка

Theano предоставляет ряд средств для отображения графа вычислений и отладки. Тем не менее, отладка символьных выражений по-прежнему остаётся задачей не из лёгких. Мы кратко перечислим тут наиболее употребимые подходы, подробнее об отладке можно прочитать в документации: http://deeplearning.net/software/theano/tutorial/printing_drawing.html

Мы можем распечатать граф вычислений для каждой функции:

x = T.lscalar('x')
y = T. lscalar('y')

square = T.square(x + y)
sqrt = T.sqrt(x + y)

f = theano.function(
    inputs=[x, y],
    outputs=[square, sqrt]
)
# сумма будет подсчитана только один раз
theano.printing.debugprint(f)

Заметьте, что сумма вычисляется только один раз:

Elemwise{Sqr}[(0, 0)] [id A] ''   2
 |Elemwise{add,no_inplace} [id B] ''   0
   |x [id C]
   |y [id D]
Elemwise{sqrt,no_inplace} [id E] ''   1
 |Elemwise{add,no_inplace} [id B] ''   0

Выражения можно выводить и в более лаконичной форме:

# определим выражение
W = T.fmatrix('W')
b = T.fvector('b')
X = T.fmatrix('X')

expr = T.dot(X, W) + b
prob = 1 / (1 + T.exp(-expr))
pred = prob > 0.5
# и распечатаем его
theano.pprint(pred)
>>> 'gt((TensorConstant{1} / (TensorConstant{1} + exp((-((X \\dot W) + b))))), TensorConstant{0.5})'

Или в виде графа:

theano.printing.pydotprint(pred, outfile='pics/pred_graph.png', var_with_name_simple=True)

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

Машинное обучение на Theano

Логистическая регрессия

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

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

W = theano.shared(
    value=numpy.zeros((2, 1),dtype=theano.config.floatX),
    name='W')

b = theano.shared(
    value=numpy.zeros((1,), dtype=theano.config.floatX),
    name='b')

И заведём символьные переменные для признаков и меток класса:

X = T.matrix('X')
Y = T.imatrix('Y')

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

linear = T. dot(X, W) + b
p_y_given_x = T.nnet.sigmoid(linear)
y_pred = p_y_given_x > 0.5

И определим функцию потерь вида:

loss = T.nnet.binary_crossentropy(p_y_given_x, Y).mean()

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

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

Давайте воплотим его в коде:

g_W = T.grad(loss, W)
g_b = T.grad(loss, b)

updates = [(W, W - 0.04 * g_W),
           (b, b - 0.08 * g_b)]

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

Когда градиенты получены, нам остаётся лишь скомпилировать Theano-функции:

train = theano.function(
    inputs=[X, Y],
    outputs=loss,
    updates=updates,
    allow_input_downcast=True
)
predict_proba = theano.function(
    [X],
    p_y_given_x,
    allow_input_downcast=True
)

И запустить итеративный процесс:

sgd_weights = [W.get_value().flatten()]
for iter_ in range(4001):
    loss = train(x, y[:, np.newaxis])
    sgd_weights.append(W.get_value().flatten())
    if iter_ % 100 == 0:
        print("[Iteration {:04d}] Train loss: {:.4f}".format(iter_, float(loss)))

Для сгенерированных мною данных процесс сходится к такой разделяющей прямой:

Выглядит неплохо, но кажется, что для такой простой задачи 4000 итераций — это как-то многовато… Давайте попробуем ускорить оптимизацию и воспользуемся методом Ньютона. Этот метод использует вторые производные функции потерь и представляет собой последовательность таких шагов:

где — матрица Гессе.

Чтобы посчитать матрицу Гессе, создадим одномерные версии параметров нашей модели:

W_init = numpy.zeros((2,),dtype=theano.config.floatX)
W_flat = theano.shared(W_init, name='W')
W = W_flat.reshape((2, 1))

b_init = numpy.zeros((1,), dtype=theano.config.floatX)
b_flat = theano.shared(b_init, name='b')
b = b_flat.reshape((1,))

И определим шаг оптимизатора:

h_W = T.nlinalg.matrix_inverse(theano.gradient.hessian(loss, wrt=W_flat))
h_b = T.nlinalg.matrix_inverse(theano.gradient.hessian(loss, wrt=b_flat))

updates_newton = [(W_flat, W_flat -  T.dot(h_W , g_W)),
           (b_flat, b_flat - T.dot(h_b, g_b))]

Хоть мы и пришли к тем же результатам,
,

Методу Ньютона для этого понадобилось всего 30 (против 4000 у градиентного спуска) шагов.

Пути обоих методов можно посмотреть на этом графике:

SVC

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

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

C = 10. 
loss = C * T.maximum(0, 1 - linear * (Y * 2 - 1)).mean() + T.square(W).sum()

predict = theano.function(
    [X],
    linear > 0,
    allow_input_downcast=True
)

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

Для выбранного С классификатор разделит пространство так:

Нелинейные признаки

Циклы являются одной из наиболее употребимых конструкций в программировании. Поддержка циклов в Theano представлена функцией scan. Давайте познакомимся с тем, как она работает. Думаю, читателям уже очевидно, что линейная функция от признаков — не лучший кандидат на разделение сгенерированных данных. Этот недостаток можно исправить, добавив полиномиальные признаки к исходным (этот приём подробно описан в другой статье нашего блога). Итак, хочется получить преобразование вида . В python мы могли бы реализовать его, например, так:

poly = []
for i in range(K):
   poly.extend([x**i for x in features])

В Theano это выглядит следующим образом:

def poly(x, degree=2):

    result, updates = theano. scan(
                                  # записываем выражение, вычисляющее каждую новую степень полинома
                                  fn=lambda prior_result, x: prior_result * x,
                                  # инициализируем выходной тензор
                                  outputs_info=T.ones_like(x),
                                  # укажем, что x надо передать в качестве второго аргумента fn
                                  non_sequences=x,
                                  # количество итераций
                                  n_steps=degree)
    # результат возвращаем в виде матрицы N x M*degree
    return result.dimshuffle(1, 0, 2).reshape((result.shape[1], 
                                               result.shape[0] * result.shape[2]))

Первой в scan передается функция, которая будет вызываться на каждой итерации, её первый аргумент — результат на предыдущей итерации, последующие — все non_sequences; outputs_info инициализирует выходной тензор такой же размерности и типа, как и x, и заполняет его единицами; n_steps указывает на требуемое количество итераций.

scan вернет результат в виде тензора размера (n_steps, ) + outputs_info.shape, поэтому мы преобразуем его в матрицу, чтобы получить нужные признаки.

Проиллюстрируем работу полученного выражения простым примером:

[[1, 2],   ->  [[ 1,  2,  1,  4],
 [3, 4],   ->   [ 3,  4,  9, 16],
 [5, 6]]   ->   [ 5,  6, 25, 36]]

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

W = theano.shared(
    value=numpy.zeros((8, 1),dtype=theano.config.floatX), 
    name='W')

linear = T.dot(poly(X, degree=4), W) + b

Новые признаки позволяют значительно лучше разделить классы:

Нейронные сети и Lasagne

К этому моменту мы уже обсудили основные этапы создания систем машинного обучения на Theano: инициализация входных переменных, определение модели, компиляция Theano-функций, цикл с шагами оптимизатора. На этом можно было бы и закончить, но очень уж хочется познакомить читателей с Lasagne — замечательной библиотекой для нейронных сетей, работающей поверх Theano. Lasagne предоставляет набор готовых компонентов: слоёв, алгоритмов оптимизации, функций потерь, инициализаций параметров и т.д., при этом не скрывает Theano за многочисленными слоями абстракций.

Рассмотрим, как может выглядеть типичный код на Theano/Lasagne на примере классификации MNIST’a.

Примеры изображений из MNIST, если вы их еще не видели

Сконструируем многослойный перцептрон с двумя скрытыми слоями по 800 нейронов, для регуляризации будем использовать dropout и разместим этот код в отдельной функции:

def build_mlp(input_var=None):
    # Входной слой, определяющий размерность данных
    # (переменный размер minibatch'a, 1 канал, 28 строк и 28 столбов) 
    # Мы можем передать тензорную переменную для входных данных,
    # или же она будет создана для нас
    network = lasagne.layers. InputLayer(
        shape=(None, 1, 28, 28),
        input_var=input_var)

    #   dropout на 20% для входных данных
    network = lasagne.layers.DropoutLayer(network, p=0.2)

    # Полносвязный слой на 800 нейронов и ReLU в качестве нелинейности
    # также инициализируем веса методом, предложенным Xavier Glorot и Yoshua Bengio
    network = lasagne.layers.DenseLayer(
        network, 
        num_units=800,
        nonlinearity=lasagne.nonlinearities.rectify,
        W=lasagne.init.GlorotUniform())

    # Добавим dropout еще на 50%:
    network = lasagne.layers.DropoutLayer(network, p=0.5)

    # И ещё один полносвязный слой
    network = lasagne.layers.DenseLayer(
        network,
        num_units=800,
        nonlinearity=lasagne.nonlinearities.rectify)

    network = lasagne.layers.DropoutLayer(network, p=0.5)

    # Наконец, добавим классификатор на 10 классов:
    network = lasagne.layers.DenseLayer(
        network,
        num_units=10,
        nonlinearity=lasagne.nonlinearities. softmax)

    return network

Получим вот такую простую полносвязную сеть:

Инициализируем тензорные переменные и скомпилируем Theano-функции для обучения и валидации:

input_var = T.tensor4('inputs')
target_var = T.ivector('targets')

# воспользуемся функцией из предыдущего листинга
network = build_mlp(input_var)

# эта функция вернёт нам граф вычислений, соответствующий сети
prediction = lasagne.layers.get_output(network)
# зададим функцию потерь
loss = lasagne.objectives.categorical_crossentropy(prediction, target_var).mean()
# Сюда также можно добавить L1 или L2 регуляризацию, см. lasagne.regularization.

# Этот метод позволит получить список параметров сети
# он также принимает keyword аргумент, позволяющий выбрать параметры по тегу
# наиболее часто употребимые это trainable и regularizable
params = lasagne.layers.get_all_params(network, trainable=True)
# используем метод стохастического градиентного спуска с моментом Нестерова
updates = lasagne. updates.nesterov_momentum(
    loss, 
    params, 
    learning_rate=0.01, 
    momentum=0.9)

# Также создадим выражение для функции потерь на валидации. 
# Главное отличие тут заключается в аргументе deterministic=True,
# который отключает dropout
test_prediction = lasagne.layers.get_output(network, deterministic=True)
test_loss = T.nnet.categorical_crossentropy(test_prediction,
                                                        target_var).mean()
# Заодно посчитаем точность классификатора
test_acc = T.mean(
    T.eq(T.argmax(test_prediction, axis=1), target_var),
    dtype=theano.config.floatX)
# скомпилируем функцию для обучения
train = theano.function(
    inputs=[input_var, target_var],
    outputs=loss,
    updates=updates)

# и вторую — для валидации
# оптимизатор Theano тут поймёт, что для вычисления функции потерь и точности
# можно переиспользовать большую часть графа
validate = theano.function(
    inputs=[input_var, target_var],
    outputs=[test_loss, test_acc])

Теперь создадим цикл обучения:

print("| Epoch | Train err | Validation err | Accuracy |  Time  |")
print("|------------------------------------------------------------------------|")

try:
    for epoch in range(100):
            # Каждую эпоху будем проходить по всей обучающей выборке
            train_err = 0
            train_batches = 0
            start_time = time. time()
            for batch in iterate_minibatches(X_train, y_train, 500, shuffle=True):
                inputs, targets = batch
                train_err += train(inputs, targets)
                train_batches += 1

            # И по всей валидационной
            val_err = 0
            val_acc = 0
            val_batches = 0
            for batch in iterate_minibatches(X_val, y_val, 500, shuffle=False):
                inputs, targets = batch
                err, acc = validate(inputs, targets)
                val_err += err
                val_acc += acc
                val_batches += 1

            print("|{:05d} | {:4.5f} | {:16.5f} | {:10.2f} | {:7.2f} |".format
                  (epoch,
                    train_err / train_batches,
                    val_err / val_batches,
                    val_acc / val_batches * 100,
                    time.time() - start_time))
except KeyboardInterrupt:
    print("The training was interrupted on epoch: {}".format(epoch))

Получившиеся кривые обучения:

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

Сохранять и загружать веса удобно с помощью хелперов:

# Сохраняем веса
savez('model.npz', *lasagne.layers.get_all_param_values(network))

network = build_mlp()
# И загружаем, когда потребуется:
with np.load('model.npz') as f:
     param_values = [f['arr_%d' % i] for i in range(len(f.files))]
lasagne.layers.set_all_param_values(network, param_values)

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

Заключение

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

Большая благодарность bauchgefuehl за помощь в подготовке поста.

1. Граница между двумя подходами довольно размыта, и не всё сказанное ниже строго верно, всегда есть исключения и пограничные случаи. Наша задача тут — передать основную идею.
2. Разработчики Theano в техническом отчёте и документации называют дифференцирование символьным. Однако, использование этого термина в одной из предыдущих статей на Хабр вызвало обсуждение. Исходя из исходного кода Theano и определения на Википедии, автор считает, что правильный термин всё же «автоматическое дифференцирование».
3. Материал этого раздела по большей части основан на документации к Lasagne.

Получить вывод из Lasagne (python deep neural network framework)

Я загрузил пример mnist_conv.py из официального github лазаньи.

В то же время я хотел бы предсказать свой собственный пример. Я видел, что «lasagne.layers.get_output()» должен обрабатывать массивы numpy из официальной документации, но это не работает, и я не могу понять, как я могу это сделать.

Вот мой код:

if __name__ == '__main__':
    output_layer = main() #the output layer from the net
    exampleChar = np.zeros((28,28)) #the example I would predict
    outputValue = lasagne.layers.get_output(output_layer, exampleChar)
    print(outputValue.eval())

но это дает мне:

TypeError: ConvOp (make_node) requires input be a 4D tensor; received "TensorConstant{(28, 28) of 0. 0}" (2 dims)

Я понимаю, что он ожидает 4D-тензор, но я понятия не имею, как его исправить.

Вы не могли бы мне помочь? Спасибо

python

deep-learning

lasagne

Поделиться

Источник

Jlearner

19 июля 2015 в 09:26

2 ответа

Matlab Neural network toolbox сохранить регрессионный график в файл
Я пытаюсь запустить сценарий matlab (сгенерированный nftool, так как мои знания matlab в лучшем случае плохи) с довольно большим набором данных через мое соединение ssh на многоядерном вычислительном сервере моей школы. Поскольку я не могу непосредственно смотреть на графический интерфейс, который…
Как установить Theano и Lasagne в Anaconda (Jupyter)?
Я пытался установить лазанью и Теано в Anaconda (Jupyter) на MacOS Sierra (10.12.3), чтобы использовать эту нейронную сеть: neural-storyteller Однако когда я пытаюсь импортировать их в Jupyter: import lasagne import theano Я получаю эту ошибку: ImportError Traceback (most recent call last). ..

Сначала вы пытаетесь передать один «image» в свою сеть, которая, таким образом, имеет измерение (256,256) .

Но для этого нужен список 3-мерных данных, то есть изображений, которые в theano реализованы как 4D тензор.

Я не вижу вашего полного кода, как вы намеревались использовать интерфейс лазаньи, но если ваш код написан правильно, то из того, что я видел до сих пор , я думаю, что вы должны сначала преобразовать свои данные (256,256) в одноканальное изображение, например (1,256,256), а затем составить список из любого использования большего количества данных (1,256,256) , переданных в списке, например [(1,256,256), (1,256,256), (1,256,256)] , или составьте список из этого единственного примера, например [(1,256,256)] .
Первый вы получаете, а затем передаете a (3,1,256,256), второй-a (1,1,256,256) 4D тензор, который будет принят интерфейсом лазаньи.

Поделиться

Geeocode

19 июля 2015 в 11:14

Как написано в вашем сообщении об ошибке, ожидается, что вход будет 4D тензором формы (n_samples, n_channel, width, height) . В случае MNIST n_channels равно 1, а width и height -28.

Но вы вводите тензор 2D формы (28, 28) . Вам нужно добавить новые оси, что вы можете сделать с помощью exampleChar = exampleChar[None, None, :, :]

exampleChar = np.zeros(28, 28)
print exampleChar.shape 
exampleChar = exampleChar[None, None, :, :]
print exampleChar.shape

выходы

(28, 28)
(1, 1, 28, 28)

Примечание: Я думаю, что вы можете использовать np.newaxis вместо None для добавления оси. И exampleChar = exampleChar[None, None] тоже должен работать.

Поделиться

P. Camilleri

14 августа 2015 в 10:08

lasagne — Neural Turing Machines используя Theano с Lasagne

NTM-Lasagne is a library to create Neural Turing Machines (NTMs) in Theano using the Lasagne library. If you want to learn more about NTMs, check out our blog post.

This library features:

A Neural Turing Machine layer NTMLayer, where all its components (controller, heads, memory) are fully customizable.
Two types of controllers: a feed-forward DenseController and a «vanilla» recurrent RecurrentController.
A dashboard to visualize the inner mechanism of the NTM.
Generators to sample examples from algorithmic tasks.

Installation

This library is compatible with Python 2.7.8, and may be partly compatible with Python 3.x. NTM-Lasagne requires the bleeding-edge versions of Lasagne and Theano. Check the Lasagne installation instructions for details, or install them with pip install -r requirements.txt. To install this library, clone this repository and then run the setup.py script.

git clone https://github.com/snipsco/ntm-lasagne.git
cd ntm-lasagne/
pip install -r requirements. txt
python setup.py install

Example

Here is minimal example to define a NTMLayer

# Neural Turing Machine Layer
memory = Memory((128, 20), memory_init=lasagne.init.Constant(1e-6),
    learn_init=False, name='memory')
controller = DenseController(l_input, memory_shape=(128, 20),
    num_units=100, num_reads=1,
    nonlinearity=lasagne.nonlinearities.rectify,
    name='controller')
heads = [
    WriteHead(controller, num_shifts=3, memory_shape=(128, 20),
        nonlinearity_key=lasagne.nonlinearities.rectify,
        nonlinearity_add=lasagne.nonlinearities.rectify,
        learn_init=False, name='write'),
    ReadHead(controller, num_shifts=3, memory_shape=(128, 20),
        nonlinearity_key=lasagne.nonlinearities.rectify,
        learn_init=False, name='read')
]
l_ntm = NTMLayer(l_input, memory=memory, controller=controller, heads=heads)

For more detailed examples, check the examples folder. If you would like to train a Neural Turing Machine on one of these examples, simply run the corresponding script, like

PYTHONPATH=.  python examples/task-copy.py

and be patient while Theano compiles the model ;-). Note: unlucky initialisation of the parameters might lead to a diverging solution witness by NaNs.

Основная нейронная сеть Theano/Lasagne с регрессией не будет набирать набор данных одного размера

I’m using a basic neural network in Theano/Lasagne to try to identify facial keypoints in images, and am currently trying to get it to learn a single image (I’ve just taken the first image from my training set). The images are 96×96 pixels, and there are 30 key points (outputs) that it needs to learn, but it fails to do so. This is my first attempt at using Theano/Lasagne, so I’m sure I’ve just missed something obvious, but I can’t see what I’ve done wrong:

import sys
import os
import time

import numpy as np
import theano
import theano.tensor as T

import lasagne
import pickle

import matplotlib.pyplot as plt

def load_data():
       with open('FKD.pickle', 'rb') as f:
           save = pickle. load(f)
           trainDataset = save['trainDataset'] # (5000, 1, 96, 96) np.ndarray of pixel values [-1,1]
           trainLabels = save['trainLabels']   # (5000, 30) np.ndarray of target values [-1,1]
           del save  # Hint to help garbage collection free up memory

           # Overtrain on dataset of 1
           trainDataset = trainDataset[:1]
           trainLabels = trainLabels[:1]

       return trainDataset, trainLabels


def build_mlp(input_var=None):

       relu = lasagne.nonlinearities.rectify
       softmax = lasagne.nonlinearities.softmax

       network = lasagne.layers.InputLayer(shape=(None, 1, imageSize, imageSize), input_var=input_var)
       network = lasagne.layers.DenseLayer(network, num_units=numLabels, nonlinearity=softmax)

       return network

def main(num_epochs=500, minibatch_size=500):

       # Load the dataset
       print "Loading data..."
       X_train, y_train = load_data()

       # Prepare Theano variables for inputs and targets
       input_var = T. tensor4('inputs')
       target_var = T.matrix('targets')

       # Create neural network model
       network = build_mlp(input_var)

       # Create a loss expression for training, the mean squared error (MSE)
       prediction = lasagne.layers.get_output(network)
       loss = lasagne.objectives.squared_error(prediction, target_var)
       loss = loss.mean()

       # Create update expressions for training
       params = lasagne.layers.get_all_params(network, trainable=True)
       updates = lasagne.updates.nesterov_momentum(loss, params, learning_rate=0.01, momentum=0.9)

       # Compile a function performing a training step on a mini-batch
       train_fn = theano.function([input_var, target_var], loss, updates=updates)

       # Collect points for final plot
       train_err_plot = []

       # Finally, launch the training loop.
       print "Starting training..."

       # We iterate over epochs:
       for epoch in range(num_epochs):
           # In each epoch, we do a full pass over the training data:
           start_time = time. time()
           train_err = train_fn(X_train, y_train)

           # Then we print the results for this epoch:
           print "Epoch %s of %s took %.3fs" % (epoch+1, num_epochs, time.time()-start_time)
           print "  training loss:\t\t%s" % train_err

           # Save accuracy to show later
           train_err_plot.append(train_err)

       # Show plot
       plt.plot(train_err_plot)
       plt.title('Graph')
       plt.xlabel('Epochs')
       plt.ylabel('Training loss')
       plt.tight_layout()
       plt.show()

imageSize = 96
numLabels = 30

if __name__ == '__main__':
       main(minibatch_size=1)

This gives me a graph that looks like this:

I’m pretty this network should be able to get the loss down to basically zero. I’d appreciate any help or thoughts on the matter 🙂

EDIT: Removed dropout and hidden layer to simplify the problem.

python neural-network theano lasagne226

5 библиотек глубокого обучения Genius Python

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

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

Почему всего 5 библиотек?

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

Нужно ли мне изучать каждую библиотеку ниже?

Нет, на самом деле вам обычно нужно выучить только 1 или 2, чтобы иметь возможность делать то, что вы хотите. Вот сводка:

Theano — это библиотека низкого уровня, которая специализируется на эффективных вычислениях. Вы можете использовать это напрямую только в том случае, если вам нужна тонкая настройка и гибкость.
TensorFlow — еще одна низкоуровневая библиотека, которая менее развита, чем Theano. Однако он поддерживается Google и предлагает готовые распределенные вычисления.
Лазанья — это легкая обертка для Theano. Используйте это, если вам нужна гибкость Theano, но вы не хотите всегда писать слои нейронной сети с нуля.
Keras — это тяжелая обертка для Theano и Tensorflow. Он минималистичный, модульный и отлично подходит для быстрых экспериментов. Это наша любимая библиотека Python для глубокого обучения и лучшее место для начала для начинающих.
MXNet — еще одна библиотека высокого уровня, похожая на Keras. Он предлагает привязки для нескольких языков и поддержку распределенных вычислений.

Почему они гениальны?

Потому что они гениальны! Итак, без лишних слов…

Наставник: Теано

Мы даем Theano звание «Наставник», потому что это привело к появлению других библиотек глубокого обучения, которые мы знаем и любим.

Например, Лазанья и Керас построены на Теано.

По своей сути Theano — это библиотека для математических вычислений с использованием многомерных массивов. Он быстрый и оптимизирован с использованием графического процессора (в 140 раз быстрее процессора!).

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

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

Например, вот как можно написать функцию логистической активации в Theano:

import theano

import theano. tensor as T

x = T.dmatrix (‘x’)

s = 1 / (1 + T.exp (-x))

logistic = theano.function ([ x], s)

логистика ([[0, 1], [-1, -2]])

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

Ресурсы

Малыш: TensorFlow

TensorFlow — «новичок в районе», и о нем много говорят.

Команда Google по искусственному интеллекту разработала TensorFlow, и недавно они сделали его открытым исходным кодом.

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

Несмотря на это, Theano по-прежнему во многих отношениях быстрее, чем TensorFlow, и поддерживает более широкий спектр операций.

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

Ресурсы

The Augment: Лазанья

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

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

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

Рассматривайте лазанью как компромисс между гибкостью Theano и простотой Keras.

Ресурсы

Киборг: Керас

Среди всех библиотек глубокого обучения Python, Keras является фаворитом. Нам это нравится по 3 причинам:

Во-первых, Keras — это оболочка, которая позволяет использовать бэкэнд Theano или TensorFlow! Это означает, что вы можете легко переключаться между ними в зависимости от вашего приложения.

Во-вторых, он имеет прекрасные руководящие принципы: модульность, минимализм, расширяемость и нативность Python. На практике это делает работу в Keras простой и приятной.

Наконец, у Keras есть готовые реализации общих сетевых структур. Настроить и запустить сверточную нейронную сеть быстро и легко.

Вот пример сверхбыстрой последовательной модели:

140002

от keras.models import Sequential

from keras.layers import Dense, Activation

# Простая архитектура прямой связи

model = Sequential ()

model.add (Dense (output_dim = 64, input_dim = 100))

model .add (Активация («relu»))

model.add (Dense (output_dim = 10))

model.add (Активация («softmax»))

# Оптимизация с SGD

model. compile ( loss =’ategorical_crossentropy ‘,

optimizer =’ sgd ‘, metrics = [‘ precision ‘])

# Подобрать модель партиями

model.fit (X_train, Y_train, nb_epoch = 5, batch_size = 32)

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

loss_and_metrics = model.evaluate (X_test, Y_test, batch_size = 32)

Легко, да? Keras — идеальная библиотека для быстрого экспериментирования. В настоящее время самым большим недостатком Keras является то, что он не поддерживает среды с несколькими GPU для параллельного обучения.

Ресурсы

Полиглот: MXNet

MXNet — это высокоуровневая библиотека, как и Keras, но сияет по-разному.

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

Однако это компенсируется поддержкой более 7 различных языковых привязок! К ним относятся C ++, Python, R, Javascript и даже Matlab.

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

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

Ресурсы

Лазанья — charlesreid1

Содержание

1 Что это такое
2 ссылки
2.1 Лазанья
2.2 Github
2.2.1 Лазанья
2.2.2 Ресурсы / обучение
2.3 Реализация документов / пример сетей
3 флага

Lasagne — это высокоуровневый интерфейс для Theano.

Лазанья

Репозиторий Github: https://github.com/Lasagne/Lasagne

Документация: https://lasagne.readthedocs.io/en/latest/

Использование лазаньи через Docker: https://lasagne. readthedocs.io/en/latest/user/installation.html#docker

Может использовать образ CPU Docker или образ GPU Docker (через nvidia-docker)

Github

Лазанья

https://github.com/Lasagne/Lasagne — основное репо

https: // github.com / Kaixhin / dockerfiles — образы Docker для Lasagne / Theano

https://agentnet.readthedocs.io/en/latest/index.html — AgentNet — это набор инструментов для разработки агентов глубокого обучения с подкреплением

Ресурсы / Обучение

https://github.com/Lasagne/Recipes — Рецепты лазаньи (примеры, модели, блокноты и т. Д.)

https://github.com/Vict0rSch/deep_learning — Уроки и ресурсы по глубокому обучению для лазаньи + Керас

https: // github.com / lesley2958 / deep-learning-python — введение в глубокое обучение с помощью theano / lasagne

https://github.com/yandexdataschool/Practical_DL — ресурсы практического курса глубокого обучения

https://github. com / yandexdataschool / Practical_RL — глубокое обучение с подкреплением в условиях дикой природы

Реализации документов / Примеры сетей

https://github.com/mikesj-public/convolutional_autoencoder — сверточный автокодер в ноутбуке lasagne / jupyter

https: // github.com / ferrine / gelato — слои байесовской сети для лазаньи

https://github.com/Kadenze/siamese_net — сиамская сеть в лазаньи / Theano

https://github.com/joelmoniz/gogh-figure — перенос в стиле Ван Гога

https://github.com/tjwei/GANotebooks — генеративные реализации состязательной нейронной сети в Lasagne, Keras и PyTorch

https://github.com/zalandoresearch/spatial_gan — пространственный генерирующая состязательная нейронная сеть (одна сеть генерирует, одна сеть пытается обнаружить фальшивые данные)

https: // github.com / luizgh / lasagne_basics — обучение CNN лазаньи на наборе данных MNIST

https://github. com/FredericGodin/DynamicCNN — динамический CNN в лазанье

https://github.com/TimSalimans/weight_norm — иллюстрация нормализации веса в лазаньи

Учебное пособие по

Lasagne с прямой связью — Vict0rsch

В этом разделе вы познакомитесь с кодом feedforward_lasagne_mnist.py (здесь), который я предлагаю вам открыть во время чтения.Это руководство широко основано на примере Lasagne mnist. Этот официальный пример действительно хорошо построен и подробен, особенно комментарии в коде. Цель здесь — немного упростить исходный код, сделать его похожим на наш пример Keras и подробно понять, что происходит, когда и почему.

Если вы еще не знакомы с тем, что такое mnist, проведите там пару минут. По сути, это набор записанных цифровых изображений размером 28 * 28 (= 784) в оттенках серого (0–255).Есть 60 000 обучающих примеров и 10 000 примеров тестирования. Примеры обучения также можно разделить на 50 000 обучающих примеров и 10 000 проверочных примеров.

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

Лазанья Документация

Github лазаньи

/! \ Имейте в виду, что лазанья в значительной степени зависит от Теано, и что для того, чтобы использовать лазанью, необходимо .Введение — это минимум, который требуется, но знать Theano более подробно было бы неплохо…

Содержание

Общая организация

Импорт

Загрузка данных

Создание сети

Выбрасывать по одной партии за раз

Запуск сети

Использование

Быстрое упражнение

Общая организация

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

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

Затем мы определяем две другие вспомогательные функции: одну для построения самой сети ( build_mlp () ), другую для генерации мини-пакетов из загруженных данных ( iterate_minibatches () ).

Основная функция: run_network () . Он делает все, что вы от него ожидаете: загружает данные, строит модель / сеть, компилирует необходимые функции Theano, обучает сеть и, наконец, тестирует ее.

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

Импорт

sys , os , time и numpy не нуждаются в пояснениях.
Мы импортируем theano и theano.tensor , потому что мы будем использовать переменные Theano и некоторые из его встроенных функций.
Затем мы импортируем библиотеку lasagne целиком
rmsprop — это оптимизатор, который мы будем использовать, как и в примере с Keras. Мы используем его в основном потому, что это один из алгоритмов, которые масштабируют скорость обучения в соответствии с градиентом.Чтобы узнать больше, см. Пояснительное видео Дж. Хинтона и слайды

Как и в Керасе, уровней являются ядром сетей. Здесь мы будем использовать только слои Dense и Dropout . InputLayer — это определенный уровень , который принимает данные, которые должны быть перенаправлены в сети.
Опять же, мы будем использовать softmax и выпрямленный линейный блок ( rectify ), функции активации
И последнее, но не менее важное: функция затрат / потерь / целей — это categoryorical_crossentropy

Загрузка данных

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

loading_data () возвращает numpy ndarrays из numpy.float32 значений с фигурами:

  X_train.shape = (50000, 1, 28, 28)
y_train.shape = (50000,)

X_val.shape = (10000, 1, 28, 28)
y_val. shape = (10000,)

X_test.shape = (10000, 1, 28, 28)
y_test.shape = (10000,)

Для входов ( X ) размеры следующие: (nb_of_examples, nb_of_channels, image_first_dimension, image_second_dimension) .Это означает, что если у вас были цветные изображения в rgb , у вас было бы 3 вместо 1 в number_of_channels . Также, если бы мы изменили форму изображений, как в примере с Keras, чтобы они имели векторные входные данные, у нас было бы 784, 1 вместо 28, 28 в качестве размера изображения.

Целями являются ndarrays с одним измерением, заполненные метками как numpy.uint8 значений.

Создание сети

  def build_mlp (input_var = None):
    l_in = InputLayer (shape = (None, 1, 28, 28), input_var = input_var)

    l_hid1 = Плотный слой (
            l_in, num_units = 500,
            нелинейность = исправление,
            W = лазанья. init.GlorotUniform ())
    l_hid1_drop = DropoutLayer (l_hid1, p = 0,4)

    l_hid2 = Плотный слой (
            l_hid1_drop, num_units = 300,
            нелинейность = исправление)
    l_hid2_drop = DropoutLayer (l_hid2, p = 0,4)

    l_out = DenseLayer (
            l_hid2_drop, num_units = 10,
            нелинейность = softmax)

    return l_out

Здесь мы складываем слои для построения сети. Каждый уровень принимает в качестве аргумента предыдущий уровень . Вот как работает Theano: шаг за шагом мы определяем, как переменные зависят друг от друга.В основном мы говорим: входной слой будет изменен первым скрытым слоем следующим образом. Следующий уровень будет делать то же самое и т. Д. Таким образом, вся сеть содержится в объекте l_out , который является экземпляром lasagne.layers.dense.DenseLayer и по сути является выражением Theano, которое зависит только от входной_var .

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

Рассматриваемая сеть выглядит следующим образом:

InputLayer ожидает 4-мерные входные данные с формами (None, 1, 28, 28) . None означает, что количество примеров для передачи не фиксировано, и сеть может принимать любой размер пакета.
Первый скрытый слой имеет 500 единиц, функцию активации выпрямленного линейного модуля и 40% отсева ( l_hid1_drop ). Веса и смещения инициализируются в соответствии с распределением GlorotUniform () (по умолчанию).
Второй скрытый уровень имеет 300 единиц, функцию активации выпрямленного линейного модуля и 40% отсева и такую же инициализацию.
Выходной слой имеет 10 единиц (потому что у нас есть 10 категорий / меток в mnist), без выпадения (конечно…) и функция активации softmax для вывода вероятности. softmax output + category_crossentropy является стандартным для мультиклассовой классификации.
Эта структура 500-300-10 взята с сайта Y. LeCun со ссылкой на G.Неопубликованная работа Хинтона

Выбрасывание одной партии за раз

  def iterate_minibatches (входы, цели, размер партии, перемешивание = False):
    assert len (входы) == len (цели)
    если перемешать:
        индексы = np.arange (len (входные данные))
        np.random.shuffle (индексы)
    для start_idx в диапазоне (0, len (входы) - размер партии + 1, размер партии):
        если перемешать:
            выдержка = индексы [start_idx: start_idx + batchsize]
        еще:
            выдержка = срез (start_idx, start_idx + batchsize)
        yield input [выдержка], target [выдержка]

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

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

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

Запуск сети

Это ядро нашего обучения, функция, которую мы будем вызывать для эффективного обучения сети.Сначала он загружает данные и строит сеть, а затем определяет выражения Theano, которые нам нужно обучить (в основном, обучать и проверять потери, обновления и расчет точности) перед их компиляцией. Затем мы переключаемся на «числовые» приложения, повторяя наши данные обучения и проверки num_epoch раз. Наконец, мы оцениваем сеть на тестовых данных.

Данные

Проверка или проверка?

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

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

 , если данные отсутствуют:
        X_train, y_train, X_val, y_val, X_test, y_test = load_dataset ()
еще:
        X_train, y_train, X_val, y_val, X_test, y_test = data

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

Theano переменные: создание сети и убытки

  # Создание переменных Theano
input_var = T.тензор4 ('входы')
target_var = T.ivector ('цели')

# Построение выражений Theano на этих переменных
сеть = build_mlp (input_var)

предсказание = lasagne. layers.get_output (сеть)
потеря = категориальная_кросцентропия (прогноз, целевая_вар)
потеря = loss.mean ()

test_prediction = lasagne.layers.get_output (сеть,
                                                    детерминированный = True)
test_loss = category_crossentropy (test_prediction, target_var)
test_loss = test_loss.mean ()
test_acc = T.mean (Т.eq (T.argmax (test_prediction, axis = 1), target_var),
                          dtype = theano.config.floatX)

Здесь много чего происходит, поэтому мы пойдем построчно.

В строках 2 и 3 мы создаем переменные Theano, которые будут распространяться в сеть.

Строка 6, мы строим сеть из переменной input_var Theano. Как указывалось ранее, network является экземпляром lasagne.layers.dense.DenseLayer , в котором указано, как прямой проход в нашу сеть влияет на input_var .

В строке 8 мы получаем переменную Theano, сгенерированную сетью из input_var . Это экземпляр theano.tensor.var.TensorVariable .

В строках 9 и 10 мы оцениваем убыток. Опять же, имейте в виду, что мы все еще говорим « буквально », здесь нет числа. Что происходит, мы вычисляем, как потери зависят от прогноза и target_var

Строки с 12 по 15, то же самое происходит, за исключением того, что на этот раз есть параметр детерминированный = Истина , что в основном означает отсутствие отсева, потому что мы тестируем нашу сеть, а не обучаем ее.

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

Составление графика: функции Theano

  params = lasagne.layers.get_all_params (network, trainable = True)
обновления = rmsprop (потеря, параметры, скорость_учения = 0,001)

# Составление графика путем объявления функций Theano
train_fn = theano. function ([input_var, target_var],
                                   потеря, обновления = обновления)
val_fn = theano.функция ([input_var, target_var],
                                 [test_loss, test_acc])

Здесь нам нужно взглянуть на (немного) большую картину. Целью обучения сети является пересылка примеров, оценка функции стоимости, а затем обновление весов и смещений в соответствии с алгоритмом обновления (здесь rmsprop, ).

Это то, что делает функция Theano train_fn строка 5: учитывая входные данные ( input_var ) и их цель ( target_var ), оценивает функцию стоимости и затем обновляет веса и смещения соответственно.

Обновления определены в строках 1 и 2 и запускаются в функции Theano ( обновлений = обновления ):
Сначала мы получаем все параметры сети, которые можно обучить, то есть веса и смещения. В нашем случае это будет список общих переменных с 3 весами и 3 смещениями. Если вы не разбираетесь в общих переменных (см. Также Quora), попробуйте сами.

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

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

Актуальная тренировка в эпоху петли

  для эпохи в диапазоне (num_epochs):

    # Просмотр обучающих данных
    train_err = 0
    train_batches = 0
    start_time = time.time ()
    для партии в iterate_minibatches (X_train, y_train,
                                             500, перемешать = True):
        входы, цели = партия
        train_err + = train_fn (входы, цели)
        train_batches + = 1

    # Просмотр данных проверки
    val_err = 0
    val_acc = 0
    val_batches = 0
    для партии в iterate_minibatches (X_val, y_val, 500, shuffle = False):
        входы, цели = партия
        err, acc = val_fn (входы, цели)
        val_err + = ошибка
        val_acc + = acc
        val_batches + = 1

    # Затем печатаем результаты для этой эпохи:
    print ("Эпоха {} из {} заняла {:. 3f} s ".format (
                эпоха + 1, num_epochs, time.time () - start_time))
    print ("потеря обучения: \ t \ t {:. 6f}". format (train_err / train_batches))
    print ("потеря проверки: \ t \ t {:. 6f}". format (val_err / val_batches))
    print ("точность проверки: \ t \ t {:. 2f}%". format (
                val_acc / val_batches * 100))

Для каждой эпохи мы тренируемся по всем обучающим данным и оцениваем потери при обучении. Затем мы просматриваем данные валидации и оцениваем потери валидации и точность валидации.

Происходит то, что мы получаем партию примеров, которые разделяем на входов и целей . Мы передаем эти числовые входные данные связанной функции Theano ( train_fn или val_fn ), которая вычисляет связанные результаты.

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

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

Проверить и вернуть сеть

  # Теперь, когда обучение окончено, давайте протестируем сеть:
test_err = 0
test_acc = 0
test_batches = 0
для партии в iterate_minibatches (X_test, y_test, 500, shuffle = False):
    входы, цели = партия
    err, acc = val_fn (входы, цели)
    test_err + = ошибка
    test_acc + = acc
    test_batches + = 1
print ("Окончательные результаты через {0} секунд:". format (
            time.time () - global_start_time))
print ("test loss: \ t \ t \ t {:. 6f}". format (test_err / test_batches))
print ("проверка точности: \ t \ t {:.2f}% ". Format (
            test_acc / test_batches * 100))
возвратная сеть

Из всего, что мы видели до сих пор, эта часть — кусок пирога. Мы просто тестируем сеть, подающую val_fn тестовыми данными, а не данными проверки.

Наконец, мы печатаем соответствующие количества и возвращаем сеть (которая, опять же, является экземпляром lasagne.layers. dense.DenseLayer .

В качестве упражнения (очень простого…) вы можете попробовать реализовать обратный вызов LossHistory из примера Keras.

Более сложным примером является изменение кода, чтобы иметь возможность повторно обучать сеть (передача network = None в качестве параметров в run_network () является самой простой частью).

Использование

  импортировать feedforward_lasagne_mnist как flm

network = flm.run_network ()

, если вы не хотите перезагружать данные каждый раз:

  импортировать feedforward_lasagne_mnist как flm

data = flm.load_data ()
сеть = flm.run_network (данные = данные)

# изменить некоторые параметры в вашем коде

перезагрузить (flm)
сеть = flm.run_network (data = data)

Используя процессор Intel i7 с тактовой частотой 3,5 ГГц и графический процессор NVidia GTX 970, мы достигаем точности 0,9829 (ошибка 1,71%) за 32,2 секунды обучения с использованием этой реализации (включая загрузку и компиляцию).

Быстрое упражнение

Хорошо, теперь вы увидели, как лазанья использует Theano. Вот небольшое упражнение, чтобы убедиться, что у вас есть все концепции в целом. Скажем, я даю вам последний уровень сети и пример. Как бы вы предсказать соответствующее число, используя эту уже обученную сеть?

Например, напишите здесь функцию get_class () :

  импортировать feedforward_lasagne_mnist как flm

данные = flm.load_data ()
_, _, X_test, _ = данные

сеть = flm.run_network (данные = данные)
пример = X_test [-10]

get_class (сеть, пример)

Эдвард Ньюэлл

word2vec — это алгоритм для генерации вложений слов, первоначально описанный в Распределенных представлениях слов и фраз.
и их композиционность Миколов и др.
Реализация word2vec в Python с использованием Theano и Lasagne

Недавно я реализовал word2vec на Python, используя Theano и Lasagne. Это помогло мне углубить понимание word2vec и дало мне возможность попрактиковаться в использовании Theano и Lasagne. Здесь я хочу предложить подробное, но доступное описание того, как работает word2vec, и как реализовать его на Python с помощью Theano и Lasagne.

Что такое word2vec?

Просто хотите получить код? pip install theano-word2vec или git clone https://github.com/enewe101/word2vec.git, затем ознакомьтесь с примерами API ниже

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

Он работает, беря очень большой корпус, скажем, 1 миллион статей в New York Times, и анализирует, как в нем распределяются слова. Помимо
текст сам по себе, ему не нужно сообщать дополнительную информацию: он узнает значение слов просто по тому, как они используются. Это делает его алгоритмом обучения без учителя.

Эта реализация

После объяснения идей, лежащих в основе word2vec, я рассмотрю его реализацию. Вы можете получить рабочий код из github или, если вы просто хотите использовать его в своих проектах, вы можете установить theano-word2vec с помощью pip. Реализация подкреплена модульными тестами, и вскоре я буду сравнивать ее с другими реализациями. word2vec иногда называют примером глубокого обучения. На самом деле это очень поверхностная архитектура. Но получаемые в результате вложения часто применяются в глубоких архитектурах. Помимо производительности, его основным преимуществом по сравнению с другими реализациями является то, что он реализован на Python с использованием Lasagne и Theano, поэтому (надеюсь) его легко взломать и интегрировать в архитектуры глубокого обучения.
вашего собственного творения!

Основные допущения

word2vec основан на двух предположениях.Одно из этих предположений — гипотеза распределения, которая заключается в том, что значение слова можно понять из слов, которые обычно находятся рядом с ним. Например, «хлеб» может иметь тенденцию появляться рядом с «есть», «испечь», «масло», «тосты» и т. Д., И это окружение дает сигнал о том, что означает «хлеб».

Вторая гипотеза заключается в том, что значение слов можно закодировать в векторах. Идея состоит в том, что каждому слову назначается вектор, и относительная ориентация этих векторов отражает что-то о семантическом характере соответствующих слов.Встраивание слов — это карта, которая назначает k-мерный вектор каждому слову с типичными значениями k от 50 до 500. Хорошее встраивание слова кодирует семантическую (и синтаксическую) информацию о словах. Например, похожим словам нужно назначить похожие векторы.

Слова, которые имеют похожие значения, должны, например, иметь похожие векторы. Назначение вектора каждому слову в словаре определяет карту, называемую вложением. word2vec — это алгоритм, который генерирует современные вложения (по состоянию на 2016 год).Для создания вложений word2vec использует статистику о том, какие слова обычно встречаются вместе в корпусе, поэтому он полагается на гипотезу распределения.

Как работает word2vec?

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

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

Шумоконтрастная оценка

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

Предыдущие методы использовали то, что на самом деле могло показаться более прямым применением гипотезы распределения. Если мы возьмем гипотезу распределения в качестве руководства, встраивание данного слова должно уловить что-то
о
какие слова обычно встречаются рядом с ним.Некоторые предыдущие методы делают это, изучая вложения, которые моделируют для заданного слова запроса \ (w \) условную вероятность нахождения данного контекстного слова \ (c \) в его окрестности: \ (p (c | w) \).

Оценка контрастности шума и, в более широком смысле, word2vec, вместо этого основана на взятии двух разных выборок и обучении модели различать их.
Первый образец, который я назову сигналом, представляет собой набор пар запрос-слово контекст-слово, \ (\ langle w, c \ rangle \), которые выбираются из корпуса текста (например.грамм. куча статей в New York Times), согласно их естественной частоте появления, \ (p (w, c) \). Эта выборка может быть выполнена путем равномерного и случайного выбора токена \ (w \) в корпусе, а затем выбора соседнего токена \ (c \)
встречающееся в окне слов \ (\ pm 3 \).

Второй образец, который я назову шумом, генерируется в соответствии с некоторым другим распределением \ (p_n (w, c) \), наиболее важным свойством которого на данный момент является то, что это не естественное распределение контекста запроса. пары в корпусе: \ (p_n (w, c) \ neq p (w, c) \).Детали \ (p_n (w, c) \) имеют значение, но мы вернемся к этому через минуту.

Во время обучения рисуются примеры сигналов и шумов, а модель настраивается таким образом, чтобы их можно было различить.
Пусть \ (C \) указывает источник конкретной пары запрос-контекст, \ (\ langle w, c \ rangle \), и пусть \ (C = 1 \) означает, что \ (\ langle w, c \ rangle \ ) был взят из обучающего корпуса (согласно \ (p (w, c) \)), и пусть \ (C = 0 \) означает, что \ (\ langle w, c \ rangle \) был сгенерирован из распределения шума \ (р_n (ш, с) \).В подходе с контрастированием шума мы пытаемся изучить модель \ (p (C = 1 | w, c) \), а не \ (p (c | w) \).

Оказывается, они очень взаимосвязаны. Оптимальная модель \ (p (C = 1 | w, c) \) неявно дает оптимальную модель для \ (p (w, c) \), которую можно восстановить, если вы знаете распределение шума, и из этого вы можно вычислить до \ (p (c | w) \), если вы знаете распространенность отдельных слов, \ (p (w) \).
То, что это работает, имеет некоторый интуитивный смысл (подумайте о том, как отличить домашних кошек от леопардов), но стоит обдумать доказательства и попытаться научить свою интуицию этому факту.Доказательство того, почему это работает, можно найти в первой теореме
Эта статья.

Использование оценки контрастности шума для изучения вложений

До сих пор мы рассмотрели, что word2vec изучает вложения, которые оптимизированы для различения шумовых пар запрос-слово контекст-слово \ (\ langle w, c \ rangle \) от пар, выбранных из корпуса. Однако чего не хватает, так это того, как вложения действительно связаны с этой задачей классификации. Это подводит нас к базовой архитектуре word2vec.
По заданному слову запроса \ (w \) и контекстному слову \ (c \) ищутся вложения для каждого, что дает два вектора, а затем скалярное произведение этих двух
векторов берется, в результате получается скаляр, который мы назовем «счетом совпадений». {-a}} \). Эта общая архитектура изображена ниже на рисунке 1:

\ [p (C = 1 | w, c) = \ sigma (v_w \ cdot v_c) \]

Рисунок 1. Слово запроса \ (w \) и контекстное слово \ (c \) переведены в свои соответствующие вложения, \ (v_w \) и \ (v_c \), каждое визуально представлено в виде ряда прямоугольников. Вероятность того, что пара \ (\ langle w, c \ rangle \) была выбрана из корпуса (в отличие от шума), находится путем взятия скалярного произведения встраиваний и передачи результата через функцию активации сигмоида.

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

Обратите внимание, как была переработана неконтролируемая проблема изучения встраивания слов
как контролируемая задача классификации. Фактически, функция потерь
используется перекрестная энтропия между фактическим и прогнозируемым источником, которая является
Общая цель классификации:
\ [J = \ sum _ {\ langle w, c \ rangle} \ Big (
С \ ln \ sigma (w \ cdot v)
+ (1-C) \ ln (1- \ sigma (w \ cdot v))
\Большой)\]

Эта целевая функция написана так, что точность классификатора увеличивается с \ (J \). Чтобы соответствовать соглашению
используя функцию потерь, мы можем вместо этого минимизировать
\ (- J \).

Отбор проб

Имея в виду общий подход, стоит обсудить некоторые детали выборки.Вернемся к вопросу, который мы отложили в начале: что мы должны использовать в качестве распределения шума? Миколов и др. Генерируют выборки шума на основе распределения униграмм, что означает просто выбор \ (w \) и \ (c \) на основе относительных частот отдельных слов в корпусе. Обратите внимание, что это отличается от распределения сигнала: в распределении шума мы собираем \ (\ langle w, c \ rangle \) путем дискретизации \ (w \) и \ (c \) независимо от их частот в корпусе, тогда как для распределения сигнала мы снова выбираем \ (w \) на основе частоты в корпусе, но затем мы выбираем \ (c \) при условии нахождения в пределах \ (\ pm 3 \) токенов \ (w \).

Обратите внимание, что это означает, что внутри вложений мы кодируем, как
\ (p (w, c) \) отличается от \ (p (w) p (c) \), и это как раз тот аспект \ (p (w, c) \), который должен быть информативным, если мы берем распределительная гипотеза серьезно. Например, слово «чернила» может не слишком часто встречаться в контексте «осьминог», но оно, вероятно, чаще встречается в этом контексте, чем случайно, потому что осьминоги производят чернила. Это то, как данное слово меняет свой контекст статистически по отношению к общему количеству слов, является информативным, и именно это фиксирует слово встраивание.{3/4} / Z \),
на самом деле дает лучшие результаты (где \ (Z \) — константа нормализации).

Выборка по корпусу и шуму может осуществляться одновременно следующим образом. Сначала мы выбираем слово запроса \ (w \), случайным образом выбирая токен в документе (т.е. в соответствии с \ (p (w) \)). Затем мы генерируем пару сигналов, случайным образом извлекая контекстное слово из слов рядом с \ (w \) в окне \ (\ pm k \), скажем, с \ (k = 3 \). {- 5} \).

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

Обзор реализации

Теперь, когда мы рассмотрели все детали того, как должен работать word2vec, давайте реализуем его на Python с помощью Theano и Lasagne. Нашим первым шагом будет написание кода, который содержит параметры внедрения и использует их для генерации прогнозов в соответствии с расчетами, изображенными на рисунке 1.Затем мы будем использовать это, чтобы настроить функцию потерь как теаносимвольный
выражение, а также определить обновления стохастического градиентного спуска для
вложение, которое изменяет вложения, чтобы минимизировать функцию потерь.
Наконец, мы проведем обучение входного корпуса, сгенерировав сигнал
и шумовые образцы. Это будет охватывать основные функции
theano-word2vec, за исключением менее интересных деталей, таких как загрузка
и спасение моделей.

Реализация базовой архитектуры word2vec

Начнем с реализации архитектуры, представленной на рисунке 1.Сначала мы импортируем необходимые модули / классы из Theano и Lasagne.
Lasagne поможет, потому что он определяет класс EmbeddingLayer, который упрощает создание выражения theano, включающего обучаемые параметры встраивания.

 
из тензора импорта
из импортных слоев лазаньи

Чтобы обеспечить некоторую модульность, я объединяю функциональные возможности, связанные с вычислениями, выраженными архитектурой на рисунке 1, внутри класса Word2VecEmbedder. Следующий код, который строит
эта архитектура является функцией __init__ этого класса.Важно знать, что этот класс обычно не создается напрямую, а вместо этого будет обернут в более крупный класс позже. Давайте сначала посмотрим на подпись звонка:

 
класс Word2VecEmbedder (объект):
    def __init __ (
        себя,
        input_var,
        размер партии,
        Dictionary_size = 100000,
        num_embedding_dimensions = 500,
. .. # Я исключил другие менее важные kwargs
    ):

Здесь input_var — символьная переменная theano.
который будет содержать набор пар слово-контекст.Каждая пара слово-контекст будет
будет отдельной строкой, поэтому нам понадобится матрица batch_size на 2 для их хранения. batch_size должен
должны быть указаны заранее, что позволяет Theano лучше оптимизировать. Dictionary_size определяет количество уникальных слов, которые должны быть внедрены, а num_embedding_dimensions — размерность найденного встраивания.

На следующем этапе мы регистрируем input_var в пространстве имен класса, а затем разделяем input_var по оси 1, что дает нам два параллельных массива: один содержит все слова, а другой — все соответствующие контексты.Это позволяет нам использовать отдельные вложения запроса и контекста.

 
        self.input_var = input_var
        self.query_input = input_var [:, 0]
        self.context_input = input_var [:, 1]

Затем мы создадим два слоя лазаньи . EmbeddingLayer s. Перед
мы делаем это, однако нам нужно передать входные данные через два отдельных lasange.layers .InputLayer s. Это всего лишь особенность подхода Лазаньи к построению нейронной архитектуры: все входящие данные должны проходить через слой ввода
перед входом в любой другой слой.

 
        # Создайте отдельные слои ввода для слов запроса и контекстных слов
        self.l_in_query = lasagne.layers.InputLayer (
            shape = (размер_пакции,), input_var = self.query_input
        )
        self.l_in_context = lasagne.layers.InputLayer (
            shape = (размер_пакции,), input_var = self.context_input
        )

        # Сделайте отдельные слои встраивания для слов запроса и контекстных слов
        self.l_embed_query = lasagne.layers.EmbeddingLayer (
            входящий = self.l_in_query,
            input_size = размер словаря,
            output_size = num_embedding_dimensions,
            W = word_embedding_init # Это был kwarg пропущен
        ) # из подписи вызова выше. self.l_embed_context = lasagne.layers.EmbeddingLayer (
            input = self.l_in_context,
            input_size = размер словаря,
            output_size = num_embedding_dimensions,
            W = context_embedding_init # Другой пропущенный kwarg.
        ) # Оба имеют разумные значения по умолчанию.

Затем мы получаем ссылки на вывод встраивания.

 
        self.query_embedding = get_output (self.l_embed_query)
        себя.context_embedding = get_output (self.l_embed_context)

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

Теперь мы хотим взять скалярное произведение каждой пары внедрения контекста запроса. Один из способов добиться этого — выполнить матричное умножение self.query_embedding на self.context_embedding.T (обратите внимание, что мы перенесли транспонирование матрицы встраивания контекста). Напомним, что умножение матрицы \ (A \) и \ (B \) дает матрицу, \ ((i, j) \) -й элемент которой является точкой
произведение строки \ (i \) в \ (A \) на строку \ (j \) в \ (B \). Конечно, нам нужно было скалярное произведение слов и контекстов из одной пары, то есть с \ (i = j \), что означает, что они находятся на главной диагонали матричного произведения:

 
        self.match_scores = tensor.dot (
            self.query_embedding, self.context_embedding.T
        ).диагональ()

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

Наконец, мы передаем каждое скалярное произведение через сигмоидальную функцию
(поэлементно):

 
        себя.вывод = сигмоид (self.match_scores)

Где я определил сигмоид вне класса как:

 
сигмоида def (tenor_var):
    возврат 1 / (1 + T.exp (-tensor_var))

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

API theano-word2vec

Чтобы начать работу с theano-word2vec, импортируйте и создайте экземпляр объекта Word2Vec :

 
    >>> из word2vec импортировать Word2Vec
    >>> word2vec = Word2Vec ()

Обучите встраивание корпуса:

 
    >>> word2vec. train_on_corpus (
    ... open ('my-corpus.txt'). read (),
    ... num_embedding_dimensions = 500
    ...)

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

 
    >>> вложения = word2vec.embed (
    ... 'это создаст список векторов. '
    ... 'Если ввод является строкой, она токенизируется.'
    ...)

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

 
    >>> other_embeddings = word2vec.embed ([
    ... 'контроль', 'токенизация', 'по', 'передача', 'а',
    ... 'tokenized', 'list'
    ...])

Выполните анологическую арифметику и найдите слово с ближайшим вложением:

 
    >>> король, мужчина, женщина = word2vec.embed ('король, мужчина, женщина')
    >>> королева = король - мужчина + женщина
    >>> выведите word2vec.nearest (queen)
    'Королева'

Сохранить и загрузить модели

 
    >>> word2vec.save ('my-embedding.npz')
    >>> word2vec.load ('my-embedding. npz')

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

 
    >>> some_input_var = theano.dmatrix ('ввод')
    >>> input_layer = lasagne.layers.InputLayer (some_input_var, форма)
    >>> embedding_layer = word2vec.layer (input_layer)
    >>> my_cool_architecture = lasagne.layers.DenseLayer (слой_встраивания)

Nolearn

nolearn содержит несколько оболочек и абстракций вокруг
существующие библиотеки нейронных сетей, в первую очередь Lasagne , а также несколько машинного обучения
служебные модули.Весь код написан для совместимости с
scikit-learn .

.. примечание ::

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

Если вы ищете альтернативу nolearn.lasagne , библиотека
который объединяет нейронные сети с scikit-learn, а затем взгляните
at skorch _, который завершает
PyTorch для scikit-learn.

.. изображение :: https://travis-ci.org/dnouri/nolearn.svg?branch=master
: target: https://travis-ci.org/dnouri/nolearn

Мы рекомендуем использовать venv _ (при использовании Python 3)
или virtualenv _
(Python 2) для установки nolearn.

nolearn содержит список известных хороших версий зависимостей, которые
мы тестируем в соответствии с требованиями .txt . Чтобы установить последнюю версию
из nolearn от Git вместе с этими известными хорошими зависимостями, запустите
эти две команды ::

pip install -r https://raw.githubusercontent.com/dnouri/nolearn/master/requirements. txt
pip install git + https: //github.com/dnouri/nolearn.git

Если вы ищете, как использовать nolearn.lasagne , то есть два
вводные руководства, которые вы можете выбрать:

Учебное пособие по использованию сверточных нейронных сетей для определения ключевых точек лица _
с кодом __
Обучение сверточных нейронных сетей с nolearn _

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

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

собственная документация nolearn __
на данный момент несколько устарел. Но есть еще ресурсы
онлайн.

Наконец, есть несколько презентаций и примеров из Интернета.Обратите внимание, что для некоторых из них может потребоваться конкретная версия nolearn и
Ласанж до бежать:

Сверточные нейронные сети Оливера Дюрра II. Практическое занятие _ с
Код __
Презентация Рулофа Питерса Python для понимания изображений _
идет без обучения.Примеры кода лазаньи
Бенджамин Боссан: задача по классификации продуктов Otto Group с использованием nolearn / lasagne ipynb> _
Инструкции Kaggle о том, как настроить экземпляр AWS GPU для запуска nolearn.lasagne _
и учебник по обнаружению ключевых точек лица
Пример сверточного автокодировщика _
Победители задачи прогнозирования заметности в 2015 LSUN Challenge _ опубликовали свои
lasagne / nolearn-based code __.
Обладатели 2-го места в конкурсе Kaggle Diabetic Retinopathy Detection _ имеют
опубликовали свой код lasagne / nolearn com/sveitser/kaggle_diabetic> __.
Обладатель 2-го места в конкурсе на распознавание китов Kaggle _ имеет
опубликовал свой код lasagne / nolearn __.

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

как воспроизвести ошибку: покажите нам, как вызвать ошибку, используя
минимальный пример
какие версии вы используете: включая ревизию и / или версию Git
не узнать (и, возможно, лазанью), что вы используете

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

Если вы считаете, что видите проблему с лазаньей,
другой программный проект, используйте трекер ошибок Lasagne com / Lasagne / Lasagne / issues> _.

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

Цитаты приветствуются:

  Даниэль Нури.2014. * nolearn: нейронная система, совместимая с scikit-learn
сетевая библиотека * https://github.com/dnouri/nolearn

См. Файл LICENSE.txt _ для получения информации о лицензионных правах и
ограничения (MIT).

Deep Learning в Windows: Руководство по началу работы

Опубликовано: 4 августа 2016 г.

Автор: noodlefrenzy

В машинном обучении.
теги: Windows Deep Learning Machine Learning Theano Keras Lasagne
ОБНОВЛЕНИЕ
См. Мой новый пост по этому поводу — все изменилось менее чем за год, поэтому потребовались довольно серьезные изменения.
Краткое руководство по глубокому обучению
Deep Learning — это относительно новый набор методов в области машинного обучения, который продемонстрировал свою способность хорошо обобщать целый ряд проблем и даже решать некоторые проблемы, которые считались неразрешимыми всего несколько лет назад.В Интернете есть множество руководств и статей по этим методам, поэтому я не буду слишком углубляться, но я изложу основы.
В течение некоторого времени люди знали, что конкретный метод машинного обучения — нейронные сети — может изучать сложные сопоставления входных данных (например, изображений) с выходными данными (например, «какая это цифра?») С помощью «скрытого слоя». «что находится между ними двумя.
С появлением Big Data у нас внезапно появились невероятно большие наборы входных данных, которые мы могли бы скормить этим моделям, и с увеличением мощности графических процессоров у нас появились вычислительные мощности для этого. В прошлом мы видели нейронные сети с несколькими скрытыми слоями, но их обучение было настолько дорогостоящим, и они, похоже, не превосходили другие методы, от которых отказались. Кто-то понял, что с таким объемом данных, которые у нас есть сейчас, и доступными нам вычислительными ресурсами, эти ограничения больше не применяются, и эти старые сети были возвращены.
С тех пор сети стали только глубже (больше скрытых слоев), а их формы стали только более странными (сверточные нейроны, петли обратной связи и пропуск слоев).На данный момент мы знаем, что они могущественны, но на самом деле не знаем, насколько сильными они могут стать, а поле для дальнейшего развития широко открыто. Для более подробной и более красноречивой истории этой области см. Отличный пост NVidia.
В этом посте я расскажу, как установить и запустить один из самых популярных наборов инструментов в Windows, а также расскажу и объясню несколько забавных примеров.
Наборы инструментов для глубокого обучения
Машинное обучение
существует уже давно, и существуют десятки фреймворков, написанных во всем, от низкоуровневого кода C до AzureML. В области глубокого обучения несколько фреймворков приобрели известность только для того, чтобы постепенно уступить место «следующей большой вещи». Трудно сказать, у кого лучший фреймворк, и многое сейчас сводится к выбору того, поддерживает ли он ваши текущие и ожидаемые потребности, работает ли он на вашей платформе и можете ли вы кодировать его на языке, который вам нравится. .
Caffe — один из старейших в этой области, и их «Модельный зоопарк» предварительно обученных моделей является убедительным аргументом в пользу сохранения полезности.С множеством руководств, хорошей документацией и привязкой для Python это хороший выбор. Его заменил Torch, фреймворк Facebook для Lua. Некоторое время это было популярно, пока его не начали заменять более современные варианты на основе Tensor. Эти тензорные сети позволяют использовать вычислительных сетей вместо сетей уровней и оказались более гибкими для современных моделей глубокого обучения.
CNTK от Microsoft и TensorFlow от Google являются системами на основе Tensor — обе работают в Linux, CNTK — в Windows, а TensorFlow — на Mac. Сегодня я сосредоточусь на одном из главных конкурентов TensorFlow — Theano. Theano — это библиотека, привязанная к Python, которую я считаю полезной, потому что она работает в низкоуровневом тензорном пространстве, но имеет библиотеки, построенные поверх нее, такие как Keras и Lasagne, которые позволяют вам думать на более высоком уровне абстракции, например, определение сверточной нейронной сети с Keras тривиально. Это не означает, что Theano лучший — на самом деле, если вы хотите увидеть более подробное сравнение фреймворков, я бы порекомендовал эту живую статью Кеннета Тран.
Теано, Керас и Лазанья
Установка в Windows
Theano, Keras и Lasagne — это библиотеки Python, поэтому первое, что нам нужно сделать, это установить Python в Windows. Для этого есть несколько отличных вариантов, но я выберу WinPython по двум причинам: во-первых, он устанавливается без побочных эффектов, поэтому может работать бок о бок с любой существующей Anaconda или другой установкой, которую вы должно быть; во-вторых, он поставляется с целым рядом пакетов, которые вам понадобятся уже предустановленными (Numpy, Pandas, Sklearn).
Установка WinPython 3.x
На момент написания (02.08.2016) WinPython 3.4.4.3 является последней ветвью дерева 3.4, а Theano еще не поддерживал Python 3.5 в Windows (вот хорошее описание того, почему). Если вы читаете это далеко в будущем, вам, вероятно, следует перейти на главную страницу WinPython и документацию по установке Theano, чтобы определить, какую версию использовать (или, если вы , очень далеко в , попросите вашего робота-дворецкого сделать это для вас). Пожалуйста, используйте 64-битную версию (или, если вы безумно в далеком будущем, 512-битную версию).
После того, как вы выбрали свою версию, установка так же тривиальна, как загрузка, двойной щелчок и выбор нужного вам места. Поскольку (как упоминалось выше) WinPython не имеет побочных эффектов, мне нравится помещать его в каталог инструментов разработчика (c: \ dev \ tools \ WinPython), чтобы его было легко найти. WinPython поставляется с собственным командным окном, в котором создаются экземпляры с правильными настройками пути, что позволяет убрать его с пути и избежать побочных эффектов.
Добавление последних Theano, Keras и Lasagne
Теперь, когда у вас установлен WinPython, давайте установим последний и самый лучший из трех наборов инструментов, которые мы используем, через pip .Запустите командную строку WinPython и введите pip --version , чтобы убедиться, что вы используете правильную версию. Следует указать каталог и версию, чтобы вы точно знали, с чем имеете дело, и затем вы могли установить пакеты через:
> pip install --upgrade --no-deps https://github.com/Theano/Theano/archive/master.zip > pip install --upgrade --no-deps https://github.com/fchollet/keras/archive/master.zip > pip install --upgrade --no-deps https: // github.com / Лазанья / Лазанья / archive / master.zip
Это устанавливает последнюю версию каждого из них непосредственно с GitHub, без обновления каких-либо зависимостей (поверьте мне, вы не хотите случайно обновлять Numpy, если вам не нравится наблюдать за ошибками компилятора).
Тестирование вашей установки
Если установлена последняя версия Theano, убедитесь, что вы можете импортировать библиотеку:
> питон >>> импортировать теано
Это займет некоторое время, но завершится успешно.Теперь вы можете клонировать примеры, которые я собрал на GitHub, и запустить пример mnist.py . Это позволит протестировать как Lasagne, так и Theano, загрузив набор данных MNIST и обучив классификатор распознавать изображения цифр.
> git clone https://github.com/noodlefrenzy/deep-learning-on-windows.git > cd глубокое обучение в окнах > python mnist.py
Если это работает успешно, вы знаете, что у вас есть рабочая версия Theano and Lasagne. Возможно, вы захотите нажать Ctrl + C до его завершения, поскольку он будет работать довольно медленно.Теперь, чтобы заставить его работать на такой скорости, когда вы действительно можете сделать с ним что-нибудь полезное.
Поддержка графического процессора
Если у вас есть графический процессор NVidia, вы можете сделать свои платформы глубокого обучения намного быстрее на с помощью CUDA и CUdnn. Сначала вы должны загрузить CUDA Toolkit и установить его, затем зарегистрироваться в CUdnn, загрузить его и установить. Обычно я «устанавливаю» CUdnn, просто копируя содержимое каталога cuda в установленный CUDA Toolkit (который для меня на v7.5 находится по адресу C: \ Program Files \ NVIDIA GPU Computing Toolkit \ CUDA \ v7.5 ). На момент написания этой статьи (2 августа 2016 г.) CUDA 8 не поддерживается Theano, поэтому я установил CUDA 7.5.
После установки библиотек вам необходимо установить соответствующую переменную среды ( CUDA_PATH ) для вашей установки (в моем случае C: \ Program Files \ NVIDIA GPU Computing Toolkit \ CUDA \ v7.5 ). Я также добавляю % CUDA_PATH% \ bin к моему PATH , чтобы у меня был доступ к различным инструментам CUDA.
Установка компилятора
Для использования CUDA 7.5 требуется установленный (старый) 64-разрядный компилятор C ++ Microsoft, в частности Visual Studio 2012 или 2013. Дополнительные сведения о CUDA в Windows см. В их руководстве по установке. Для тех из вас, у кого нет VS2013 или подписки MSDN, скачайте версию сообщества.
Настройка Theano для использования GPU
Theano имеет несколько параметров конфигурации, которые управляют построением и запуском моделей, поэтому, чтобы заставить его работать с использованием вашего графического процессора, вам необходимо перенастроить его.Поскольку это, вероятно, то, что вам нужно для всего вашего кода Theano, я создаю файл .theanorc для всей моей установки WinPython в каталоге settings в WinPython (для меня это C: \ dev \ tools \ WinPython \ настройки ). Я разместил пример файла конфигурации Theano в моем репозитории GitHub, но основные настройки:
[весь мир] device = gpu [nvcc] compiler_bindir = C: \ Program Files (x86) \ Microsoft Visual Studio 12.0 \ VC \ bin \ amd64 flags = - cl-version = 2013
(Повторное) тестирование вашей установки
Теперь, когда вы включили поддержку графического процессора, попробуйте снова запустить пример MNIST ( python mnist. py ) и посмотрите, какое значение имеет наличие графического процессора — время для обучения отдельной эпохи должно быть значительно сокращено.
Глубокие сновидения
Я должен передать это в Google; их сообщения от команды DeepMind были одними из самых интересных в этой области, не в последнюю очередь они представляли «Deep Dream» и «Neural Artwork».Мы можем воспроизвести аналогичные результаты, используя Keras, с примером deep_dream.py из моего репо. Эта программа использует сверточные слои сети VGG16 (из Visual Geometry Group) с предварительно обученными весами (преобразованными из Caffe). VGG16 была топовой моделью на конкурсе ImageNet (ILSVRC) 2014 года и считается отличной игровой площадкой, потому что она работает достаточно хорошо, но ее структуру относительно легко понять.
Предположим, вы установили предварительно обученные веса в C: \ dev \ data и работаете с C: \ dev \ images \ ninjacat.png , вы можете использовать следующую команду:
> python deep_dream. py --weights_root c: \ dev \ data c: \ dev \ images \ ninjacat.png ninjadream
И это будет
в
Если вы столкнетесь с ошибками, это может быть связано с изменениями в способе работы Keras или Theano или в том, как они интегрируются с CUDA или CUdnn — все они очень активно развиваются. Если да, взгляните на официальный deep_dream.py от Keras — в моей копии только что улучшена обработка аргументов и учтено несколько вещей, чтобы упростить игру.
Нейронное искусство
Neural Artistry впервые появилась в статье из Германии и с тех пор стала еще одним важным демонстрационным примером силы глубокого обучения. По сути, способ его работы заключается в том, чтобы взять существующую обученную сверточную нейронную сеть и использовать ее для свертки двух изображений вместе путем объединения выходных данных разных сверточных слоев из каждого изображения.Предположим (опять же), что вы установили предварительно обученные веса VGG16 в C: \ dev \ data и работаете с C: \ dev \ images \ ninjacat. png в стиле, скажем, «The Scream «(который находится по адресу C: \ dev \ images \ thescream.png ), ваша команда будет выглядеть так:
> python neural_style_transfer.py --weights_root c: \ dev \ data c: \ dev \ images \ ninjacat.png c: \ dev \ images \ thescream.png ninjascream
И это превратилось бы в
в
Еще раз, если вы столкнетесь с ошибками, попробуйте официальный neural_style_transfer.Пример py — моя копия просто учитывает обработку аргументов и позволяет вам поиграть с тем, какие слои вы используете для передачи.
Заключение и дальнейшая работа
Настроить наборы инструментов глубокого обучения в Windows довольно просто, и они упростили возможность экспериментировать с ними, даже если у вас нет опыта работы в этой области. TensorFlow для Windows скоро появится, но будет обеспечена поддержка Bazel — как только это произойдет, я создам последующий пост в своем блоге и рассмотрю аналогичный набор примеров, но до тех пор ничто не мешает вам присоединиться к Deep Learning. революция на вашем компьютере с Windows.
Запуск Lasagne через Jupyter на экземпляре AWS GPU — Александр Сандровский
Lasagne — это мощная библиотека Python для построения и обучения нейронных сетей в Theano. Однако вы не получите всех преимуществ, если у вас нет графического процессора с поддержкой CUDA. К счастью, мы можем использовать Amazon Web Services, сочетающие удобство и разумные цены. Нам нужно только один раз создать и настроить экземпляр, а затем запускать / останавливать его, когда нам понадобится.
Уведомление
Процесс запуска экземпляра графического процессора на AWS выходит за рамки этой статьи.Это довольно просто и описано во многих других руководствах.
Тем не менее, есть пара предостережений, которые я хотел бы упомянуть:
Предполагается, что вы используете образ Ubuntu 14.04.
Экземпляры
GPU доступны не во всех регионах, поэтому, если вы не можете найти их в списке типов экземпляров, просто попробуйте другой регион.
По умолчанию группа безопасности имеет только правило SSH, нам также понадобится доступ по HTTP (протокол: TCP / IP, порт: 80).
Поехали!
CUDA
1) Установите CUDA вместе с зависимостями.
$ wget http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1404/x86_64/cuda-repo-ubuntu1404_7.5-18_amd64.deb $ sudo dpkg -i cuda-repo-ubuntu1404_7.5-18_amd64.deb $ rm -f cuda-репо-ubuntu1404_7.5-18_amd64.deb $ sudo apt-get update $ sudo apt-get install build-essential linux-image-extra-virtual linux-source linux-source linux-headers-generic cuda
2) Задайте переменные среды.
$ echo -e "\ nPATH = / usr / local / cuda / bin: \ $ PATH" >> ~ /.профиль $ sudo sh -c "echo / usr / local / cuda / lib64> /etc/ld.so.conf.d/cuda.conf" $ sudo ldconfig
3) Перезагрузите и добавьте в ядро модуль nvidia .
$ перезагрузка sudo $ sudo modprobe nvidia
Теано + Лазанья
4) Установите последние версии Theano и Lasagne прямо с GitHub.
$ sudo apt-get install git gfortran libopenblas-dev python-dev python-pip python-нос python-numpy python-scipy $ sudo pip install --no-deps git + git: // github.ru / Theano / Theano.git $ sudo pip install --no-deps git + git: //github.com/Lasagne/Lasagne.git
5) Настройте Theano на использование графического процессора по умолчанию.
$ echo -e "[global] \ nfloatX = float32 \ ndevice = gpu"> ~ / .theanorc
Мы установим переменную среды THEANO_FLAGS в конфигурации службы Upstart, поэтому этот шаг является необязательным и необходим только в том случае, если вы хотите запускать сценарии через командную строку.
Jupyter
6) Установите Jupyter
$ sudo pip install jupyter
7) и создайте конфигурацию Upstart, чтобы запускать Jupyter при загрузке или запускать / останавливать его через командную строку, когда это необходимо.
$ mkdir / home / ubuntu / ноутбуки $ cd / etc / init / $ sudo wget https://gist.githubusercontent.com/Sundrique/6e55772def21f4aa4369/raw/4e92708401df337887c000fde97ea693d5e22050/jupyter-notebook.conf $ sudo start jupyter-notebook
Готово
8) Вы можете проверить свою установку, загрузив блокнот IPython с примером Lasagne MNIST и запустив его в браузере.
$ cd / home / ubuntu / ноутбуки $ wget https://gist.githubusercontent.com/Sundrique/5e401c96b5fde428d268/raw/61267f7abaa40b06e9e64374c1b33978a4584556/MNIST.ipynb
9) Откройте общедоступный DNS вашего экземпляра в браузере, и вы должны увидеть там интерфейс Jupyter.
10) Не забывайте останавливать экземпляр, если он вам больше не нужен.
pythonjupyterlasagnetheanogpuawscudaubuntu
.
No related posts.