Данные об угле кодирования для нейронной сети

Я тренирую нейронную сеть (детали не важны), где целевые данные - это вектор углов (между 0 и 2 * пи). Я ищу совет о том, как кодировать эти данные. Вот что я сейчас пытаюсь (с ограниченным успехом):

1) Кодирование 1-в-C: я устанавливаю возможные углы в 1000 или около того дискретных углов, а затем указываю конкретный угол, помещая 1 в соответствующий индекс. Проблема в том, что сеть просто учится выводить все 0 (поскольку это почти точно правильно).

2) Простое масштабирование: я масштабировал выходной диапазон сети ([0,1]) до [0,2 * pi]. Проблема здесь в том, что углы, естественно, имеют круговую топологию (т. Е. 0,0001 и 2 * pi на самом деле находятся рядом друг с другом). При таком типе кодирования эта информация теряется.

Мы ценим любые предложения!

Вступление

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

Таким образом, мы могли бы рассматривать это как представление / кодирование вывода, что я и делаю в этом ответе. Я продолжаю думать, что есть лучший способ, где вы можете просто использовать немного другую функцию потерь. (Возможно, сумма квадратов разностей, используя вычитание по модулю 2 ).$\pi$

Но далее с фактическим ответом.

метод

Я предлагаю представить угол в виде пары значений, его синуса и косинуса.$\theta$

Таким образом, функция кодирования: а функция декодирования: Для arctan2, являющегося обратными касательными, сохраняя направление во всех квадрантах)$\qquad\qquad\quad\theta \mapsto (\sin(\theta), \cos(\theta))$
$\qquad(y_1,y_2) \mapsto \arctan\!2(y_1,y_2)$

_{Теоретически, вы можете эквивалентно работать напрямую с углами, если ваш инструмент поддерживает atan2функцию слоя (беря ровно 2 входа и получая 1 выход). TensorFlow делает это сейчас и поддерживает градиентный спуск , хотя и не предназначен для этого использования. Я исследовал использование out = atan2(sigmoid(ylogit), sigmoid(xlogit)) с функцией потерь min((pred - out)^2, (pred - out - 2pi)^2). Я обнаружил, что он тренируется гораздо хуже, чем outs = tanh(ylogit), outc = tanh(xlogit)) с функцией потери 0.5((sin(pred) - outs)^2 + (cos(pred) - outc)^2. Что, я думаю, можно объяснить прерывистостью градиентаatan2}

Мое тестирование здесь запускает его как функцию предварительной обработки

Чтобы оценить это, я определил задачу:

Учитывая черно-белое изображение, представляющее одну линию на пустом фоне. Выведите, под каким углом эта линия находится к «положительной оси X»

Я реализовал функцию случайного генерирования этих изображений со линиями под случайными углами (примечание: в более ранних версиях этого поста использовались случайные наклоны, а не случайные углы. Спасибо @Ari Herman за указание на это. Теперь это исправлено). Я построил несколько нейронных сетей, чтобы оценить эффективность выполнения задачи. Полная информация о реализации находится в этой записной книжке Jupyter . Код целиком на Юлии , и я использую библиотеку нейронных сетей Mocha .

Для сравнения я представляю его против альтернативных методов масштабирования до 0,1. и положить в 500 бункеров и использовать softmax. Я не особенно доволен последним, и чувствую, что мне нужно его настроить. Вот почему, в отличие от других, я тестирую его только на 1000 итераций, в отличие от двух других, которые были запущены на 1000 и на 10000

Экспериментальная установка

Изображения были пикселей, с линией, начинающейся в центре и идущей к краю. На изображении не было никаких шумов и т. Д., Только «черная» линия на белом фоне.$101\times101$

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

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

Он обучался Stochastic Gradient Decent с фиксированной скоростью обучения 0,01 и фиксированным импульсом 0,9.

Регуляризация или отсев не использовались. Также не было никакого вида свертки и т. Д. Простая сеть, которая, я надеюсь, предполагает, что эти результаты будут обобщать

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

Результаты

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

|                        |  500 bins    |  scaled to 0-1 |  Sin/Cos     |  scaled to 0-1 |  Sin/Cos     |
|                        | 1,000 Iter   | 1,000 Iter     | 1,000 iter   | 10,000 Iter    | 10,000 iter  |
|------------------------|--------------|----------------|--------------|----------------|--------------|
| mean_error             | 0.4711263342 | 0.2225284486   | 2.099914718  | 0.1085846429   | 2.1036656318 |
| std(errors)            | 1.1881991421 | 0.4878383767   | 1.485967909  | 0.2807570442   | 1.4891605068 |
| minimum(errors)        | 1.83E-006    | 1.82E-005      | 9.66E-007    | 1.92E-006      | 5.82E-006    |
| median(errors)         | 0.0512168533 | 0.1291033982   | 1.8440767072 | 0.0562908143   | 1.8491085947 |
| maximum(errors)        | 6.0749693965 | 4.9283551248   | 6.2593307366 | 3.735884823    | 6.2704853962 |
| accurancy              | 0.00%        | 0.00%          | 0.00%        | 0.00%          | 0.00%        |
| accurancy_to_point001  | 2.10%        | 0.30%          | 3.70%        | 0.80%          | 12.80%       |
| accurancy_to_point01   | 21.90%       | 4.20%          | 37.10%       | 8.20%          | 74.60%       |
| accurancy_to_point1    | 59.60%       | 35.90%         | 98.90%       | 72.50%         | 99.90%       |

Когда я ссылаюсь на ошибку, это абсолютная величина разницы между углом, выведенным нейронной сетью, и истинным углом. Таким образом, средняя ошибка (например) - это среднее значение для 1000 тестовых случаев этой разницы и т. Д. Я не уверен, что мне не следует масштабировать ее, сделав ошибку, скажем, равной к ошибке ).$\frac{7\pi}{4}$$\frac{\pi}{4}$

Я также представляю точность на разных уровнях детализации. Точность, являющаяся частью тестовых случаев, была исправлена. Таким accuracy_to_point01образом, это означает, что он был посчитан как правильный, если результат был в пределах 0,01 от истинного угла. Ни одно из представлений не дало идеальных результатов, но это не удивительно, учитывая, как работает математика с плавающей запятой.

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

обсуждение

Биннинг с softmax работает намного хуже, поскольку я сказал, что не уверен, что ничего не испортил в реализации. Это работает чуть выше, чем скорость догадки, хотя. если бы это было только предположение, мы получили бы среднюю ошибку$\pi$

Кодирование sin / cos работает значительно лучше, чем масштабированное кодирование 0-1. Улучшение в том, что при 1000 обучающих итерациях sin / cos работает примерно в 3 раза лучше по большинству показателей, чем масштабирование при 10000 итераций.

Я думаю, что отчасти это связано с улучшением обобщения, так как оба получали довольно схожую среднеквадратичную ошибку в обучающем множестве, по крайней мере, один раз было выполнено 10 000 итераций.

Безусловно, существует верхний предел наилучшей возможной производительности в этой задаче, учитывая, что Угол может быть больше или меньше любого действительного числа, но не все такие ангелы выдают разные линии с разрешением пикселей. Так как, например, углы 45.0 и 45.0000001 оба связаны с одним и тем же изображением с таким разрешением, ни один метод никогда не получит оба совершенно правильных.$101\times101$

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

Вывод.

Кажется, что представление sin / cos является безусловно лучшим из представлений, которые я исследовал здесь. Это имеет смысл, поскольку оно имеет плавное значение при перемещении по кругу. Мне также нравится, что обратное можно сделать с помощью arctan2 , что элегантно.

Я полагаю, что поставленная задача достаточна в ее способности представить разумную проблему для сети. Хотя я полагаю, что на самом деле это просто обучение подгонке кривой к так что, возможно, это слишком просто. И, возможно, хуже, это может быть в пользу парного представления. Я не думаю, что это так, но здесь уже поздно, поэтому я мог что-то упустить, и я приглашаю вас снова просмотреть мой код . Предлагайте улучшения или альтернативные задачи.$f(x)=\frac{y1}{y2} x$

Вот еще одна реализация Python, сравнивающая предложенную Линдоном Уайтом кодировку с бинн-подходом. Код ниже выдает следующий вывод:

Training Size: 100
Training Epochs: 100
Encoding: cos_sin
Test Error: 0.017772154610047136
Encoding: binned
Test Error: 0.043398792553251526

Training Size: 100
Training Epochs: 500
Encoding: cos_sin
Test Error: 0.015376604917819397
Encoding: binned
Test Error: 0.032942592915322394

Training Size: 1000
Training Epochs: 100
Encoding: cos_sin
Test Error: 0.007544091937411164
Encoding: binned
Test Error: 0.012796594492198667

Training Size: 1000
Training Epochs: 500
Encoding: cos_sin
Test Error: 0.0038051515079569097
Encoding: binned
Test Error: 0.006180633805557207

$(\sin(\theta), \cos(\theta))$$(\sin(\theta), \cos(\theta))$

import matplotlib.pyplot as plt
import numpy as np
import torch
import torch.nn as nn
import torch.utils.data

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")


class Net(nn.Module):
    def __init__(self, input_size, hidden_size, num_out):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.sigmoid = nn.Sigmoid()
        self.fc2 = nn.Linear(hidden_size, num_out)

    def forward(self, x):
        out = self.fc1(x)
        out = self.sigmoid(out)
        out = self.fc2(out)
        return out


def gen_train_image(angle, side, thickness):
    image = np.zeros((side, side))
    (x_0, y_0) = (side / 2, side / 2)
    (c, s) = (np.cos(angle), np.sin(angle))
    for y in range(side):
        for x in range(side):
            if (abs((x - x_0) * c + (y - y_0) * s) < thickness / 2) and (
                    -(x - x_0) * s + (y - y_0) * c > 0):
                image[x, y] = 1

    return image.flatten()


def gen_data(num_samples, side, num_bins, thickness):
    angles = 2 * np.pi * np.random.uniform(size=num_samples)
    X = [gen_train_image(angle, side, thickness) for angle in angles]
    X = np.stack(X)

    y = {"cos_sin": [], "binned": []}
    bin_size = 2 * np.pi / num_bins
    for angle in angles:
        idx = int(angle / bin_size)
        y["binned"].append(idx)
        y["cos_sin"].append(np.array([np.cos(angle), np.sin(angle)]))

    for enc in y:
        y[enc] = np.stack(y[enc])

    return (X, y, angles)


def get_model_stuff(train_y, input_size, hidden_size, output_sizes,
                    learning_rate, momentum):
    nets = {}
    optimizers = {}

    for enc in train_y:
        net = Net(input_size, hidden_size, output_sizes[enc])
        nets[enc] = net.to(device)
        optimizers[enc] = torch.optim.SGD(net.parameters(), lr=learning_rate,
                                          momentum=momentum)

    criterions = {"binned": nn.CrossEntropyLoss(), "cos_sin": nn.MSELoss()}
    return (nets, optimizers, criterions)


def get_train_loaders(train_X, train_y, batch_size):
    train_X_tensor = torch.Tensor(train_X)

    train_loaders = {}

    for enc in train_y:
        if enc == "binned":
            train_y_tensor = torch.tensor(train_y[enc], dtype=torch.long)
        else:
            train_y_tensor = torch.tensor(train_y[enc], dtype=torch.float)

        dataset = torch.utils.data.TensorDataset(train_X_tensor, train_y_tensor)
        train_loader = torch.utils.data.DataLoader(dataset=dataset,
                                                   batch_size=batch_size,
                                                   shuffle=True)
        train_loaders[enc] = train_loader

    return train_loaders


def show_image(image, side):
    img = plt.imshow(np.reshape(image, (side, side)), interpolation="nearest",
                     cmap="Greys")
    plt.show()


def main():
    side = 101
    input_size = side ** 2
    thickness = 5.0
    hidden_size = 500
    learning_rate = 0.01
    momentum = 0.9
    num_bins = 500
    bin_size = 2 * np.pi / num_bins
    half_bin_size = bin_size / 2
    batch_size = 50
    output_sizes = {"binned": num_bins, "cos_sin": 2}
    num_test = 1000

    (test_X, test_y, test_angles) = gen_data(num_test, side, num_bins,
                                             thickness)

    for num_train in [100, 1000]:

        (train_X, train_y, train_angles) = gen_data(num_train, side, num_bins,
                                                    thickness)
        train_loaders = get_train_loaders(train_X, train_y, batch_size)

        for epochs in [100, 500]:

            (nets, optimizers, criterions) = get_model_stuff(train_y, input_size,
                                                             hidden_size, output_sizes,
                                                             learning_rate, momentum)

            for enc in train_y:
                optimizer = optimizers[enc]
                net = nets[enc]
                criterion = criterions[enc]

                for epoch in range(epochs):
                    for (i, (images, ys)) in enumerate(train_loaders[enc]):
                        optimizer.zero_grad()

                        outputs = net(images.to(device))
                        loss = criterion(outputs, ys.to(device))
                        loss.backward()
                        optimizer.step()


            print("Training Size: {0}".format(num_train))
            print("Training Epochs: {0}".format(epochs))
            for enc in train_y:
                net = nets[enc]
                preds = net(torch.tensor(test_X, dtype=torch.float).to(device))
                if enc == "binned":
                    pred_bins = np.array(preds.argmax(dim=1).detach().cpu().numpy(),
                                         dtype=np.float)
                    pred_angles = bin_size * pred_bins + half_bin_size
                else:
                    pred_angles = torch.atan2(preds[:, 1], preds[:, 0]).detach().cpu().numpy()
                    pred_angles[pred_angles < 0] = pred_angles[pred_angles < 0] + 2 * np.pi

                print("Encoding: {0}".format(enc))
                print("Test Error: {0}".format(np.abs(pred_angles - test_angles).mean()))

            print()


if __name__ == "__main__":
    main()

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

Каждая протестированная сеть имеет один скрытый слой (размер = 500) с логистическими нейронами. Выходные нейроны являются либо линейными, либо softmax, как отмечено. Я использовал 1000 тренировочных изображений и 1000 тестовых изображений, которые были сгенерированы случайным образом независимо (поэтому могут быть повторы). Обучение состояло из 50 итераций по обучающему набору.

Мне удалось получить довольно хорошую точность, используя биннинг и «гауссовское» кодирование (имя, которое я придумал; похоже на биннинг, за исключением того, что целевой выходной вектор имеет форму exp (-pi * ([1,2,3, ... , 500] - idx) ** 2) где idx - индекс, соответствующий правильному углу). Код ниже; вот мои результаты:

Тестовая ошибка для (cos, sin) кодирования:

1000 тренировочных изображений, 1000 тестовых изображений, 50 итераций, линейный вывод

• Среднее значение: 0,0911558142071

• Медиана: 0.0429723541743

• Минимум: 2.77769843793e-06

• Максимум: 6.2608513539

• Точность до 0,1: 85,2%

• Точность до 0,01: 11,6%

• Точность до 0,001: 1,0%

Тестовая ошибка для кодировки [-1,1]:

1000 тренировочных изображений, 1000 тестовых изображений, 50 итераций, линейный вывод

• Среднее значение: 0,234181700523

• Медиана: 0.17460197307

• Минимум: 0.000473665840258

• Максимум: 6,00637777237

• Точность до 0,1: 29,9%

• Точность до 0,01: 3,3%

• Точность до 0,001: 0,1%

Тестовая ошибка для кодировки 1 из 500:

1000 тренировочных изображений, 1000 тестовых изображений, 50 итераций, вывод softmax

• Среднее значение: 0,0298767021922

• Медиана: 0.00388858079174

• Минимум: 4.08712407829e-06

• Максимум: 6.2784479965

• Точность до 0,1: 99,6%

• Точность до 0,01: 88,9%

• Точность до 0,001: 13,5%

Тестовая ошибка для гауссовой кодировки:

1000 тренировочных изображений, 1000 тестовых изображений, 50 итераций, вывод softmax

• Среднее значение: 0,0296905377463
• Медиана: 0.00365867335107
• Минимум: 4.08712407829e-06
• Максимум: 6.2784479965
• Точность до 0,1: 99,6%
• Точность до 0,01: 90,8%
• Точность до 0,001: 14,3%

Я не могу понять, почему наши результаты противоречат друг другу, но, похоже, это требует дальнейшего изучения.

# -*- coding: utf-8 -*-
"""
Created on Mon Jun 13 16:59:53 2016

@author: Ari
"""

from numpy import savetxt, loadtxt, round, zeros, sin, cos, arctan2, clip, pi, tanh, exp, arange, dot, outer, array, shape, zeros_like, reshape, mean, median, max, min
from numpy.random import rand, shuffle
import matplotlib.pyplot as plt

###########
# Functions
###########

# Returns a B&W image of a line represented as a binary vector of length width*height
def gen_train_image(angle, width, height, thickness):
    image = zeros((height,width))
    x_0,y_0 = width/2, height/2
    c,s = cos(angle),sin(angle)
    for y in range(height):
        for x in range(width):
            if abs((x-x_0)*c + (y-y_0)*s) < thickness/2 and -(x-x_0)*s + (y-y_0)*c > 0:
                image[x,y] = 1
    return image.flatten()

# Display training image    
def display_image(image,height, width):    
    img = plt.imshow(reshape(image,(height,width)), interpolation = 'nearest', cmap = "Greys")
    plt.show()    

# Activation function
def sigmoid(X):
    return 1.0/(1+exp(-clip(X,-50,100)))

# Returns encoded angle using specified method ("binned","scaled","cossin","gaussian")
def encode_angle(angle, method):
    if method == "binned": # 1-of-500 encoding
        X = zeros(500)
        X[int(round(250*(angle/pi + 1)))%500] = 1
    elif method == "gaussian": # Leaky binned encoding
        X = array([i for i in range(500)])
        idx = 250*(angle/pi + 1)
        X = exp(-pi*(X-idx)**2)
    elif method == "scaled": # Scaled to [-1,1] encoding
        X = array([angle/pi])
    elif method == "cossin": # Oxinabox's (cos,sin) encoding
        X = array([cos(angle),sin(angle)])
    else:
        pass
    return X

# Returns decoded angle using specified method
def decode_angle(X, method):
    if method == "binned" or method == "gaussian": # 1-of-500 or gaussian encoding
        M = max(X)
        for i in range(len(X)):
            if abs(X[i]-M) < 1e-5:
                angle = pi*i/250 - pi
                break
#        angle = pi*dot(array([i for i in range(500)]),X)/500  # Averaging
    elif method == "scaled": # Scaled to [-1,1] encoding
        angle = pi*X[0]
    elif method == "cossin": # Oxinabox's (cos,sin) encoding
        angle = arctan2(X[1],X[0])
    else:
        pass
    return angle

# Train and test neural network with specified angle encoding method
def test_encoding_method(train_images,train_angles,test_images, test_angles, method, num_iters, alpha = 0.01, alpha_bias = 0.0001, momentum = 0.9, hid_layer_size = 500):
    num_train,in_layer_size = shape(train_images)
    num_test = len(test_angles)

    if method == "binned":
        out_layer_size = 500
    elif method == "gaussian":
        out_layer_size = 500
    elif method == "scaled":
        out_layer_size = 1
    elif method == "cossin":
        out_layer_size = 2
    else:
        pass

    # Initial weights and biases
    IN_HID = rand(in_layer_size,hid_layer_size) - 0.5 # IN --> HID weights
    HID_OUT = rand(hid_layer_size,out_layer_size) - 0.5 # HID --> OUT weights
    BIAS1 = rand(hid_layer_size) - 0.5 # Bias for hidden layer
    BIAS2 = rand(out_layer_size) - 0.5 # Bias for output layer

    # Initial weight and bias updates
    IN_HID_del = zeros_like(IN_HID)
    HID_OUT_del = zeros_like(HID_OUT)
    BIAS1_del = zeros_like(BIAS1)
    BIAS2_del = zeros_like(BIAS2)

    # Train
    for j in range(num_iters):
        for i in range(num_train):
            # Get training example
            IN = train_images[i]
            TARGET = encode_angle(train_angles[i],method) 

            # Feed forward and compute error derivatives
            HID = sigmoid(dot(IN,IN_HID)+BIAS1)

            if method == "binned" or method == "gaussian": # Use softmax
                OUT = exp(clip(dot(HID,HID_OUT)+BIAS2,-100,100))
                OUT = OUT/sum(OUT)
                dACT2 = OUT - TARGET
            elif method == "cossin" or method == "scaled": # Linear
                OUT = dot(HID,HID_OUT)+BIAS2 
                dACT2 = OUT-TARGET 
            else:
                print("Invalid encoding method")

            dHID_OUT = outer(HID,dACT2)
            dACT1 = dot(dACT2,HID_OUT.T)*HID*(1-HID)
            dIN_HID = outer(IN,dACT1)
            dBIAS1 = dACT1
            dBIAS2 = dACT2

            # Update the weight updates 
            IN_HID_del = momentum*IN_HID_del + (1-momentum)*dIN_HID
            HID_OUT_del = momentum*HID_OUT_del + (1-momentum)*dHID_OUT
            BIAS1_del = momentum*BIAS1_del + (1-momentum)*dBIAS1
            BIAS2_del = momentum*BIAS2_del + (1-momentum)*dBIAS2

            # Update the weights
            HID_OUT -= alpha*dHID_OUT
            IN_HID -= alpha*dIN_HID
            BIAS1 -= alpha_bias*dBIAS1
            BIAS2 -= alpha_bias*dBIAS2

    # Test
    test_errors = zeros(num_test)
    angles = zeros(num_test)
    target_angles = zeros(num_test)
    accuracy_to_point001 = 0
    accuracy_to_point01 = 0
    accuracy_to_point1 = 0

    for i in range(num_test):

        # Get training example
        IN = test_images[i]
        target_angle = test_angles[i]

        # Feed forward
        HID = sigmoid(dot(IN,IN_HID)+BIAS1)

        if method == "binned" or method == "gaussian":
            OUT = exp(clip(dot(HID,HID_OUT)+BIAS2,-100,100))
            OUT = OUT/sum(OUT)
        elif method == "cossin" or method == "scaled":
            OUT = dot(HID,HID_OUT)+BIAS2 

        # Decode output 
        angle = decode_angle(OUT,method)

        # Compute errors
        error = abs(angle-target_angle)
        test_errors[i] = error
        angles[i] = angle

        target_angles[i] = target_angle
        if error < 0.1:
            accuracy_to_point1 += 1
        if error < 0.01: 
            accuracy_to_point01 += 1
        if error < 0.001:
            accuracy_to_point001 += 1

    # Compute and return results
    accuracy_to_point1 = 100.0*accuracy_to_point1/num_test
    accuracy_to_point01 = 100.0*accuracy_to_point01/num_test
    accuracy_to_point001 = 100.0*accuracy_to_point001/num_test

    return mean(test_errors),median(test_errors),min(test_errors),max(test_errors),accuracy_to_point1,accuracy_to_point01,accuracy_to_point001

# Dispaly results
def display_results(results,method):
    MEAN,MEDIAN,MIN,MAX,ACC1,ACC01,ACC001 = results
    if method == "binned":
        print("Test error for 1-of-500 encoding:")
    elif method == "gaussian":
        print("Test error for gaussian encoding: ")
    elif method == "scaled":
        print("Test error for [-1,1] encoding:")
    elif method == "cossin":
        print("Test error for (cos,sin) encoding:")
    else:
        pass
    print("-----------")
    print("Mean: "+str(MEAN))
    print("Median: "+str(MEDIAN))
    print("Minimum: "+str(MIN))
    print("Maximum: "+str(MAX))
    print("Accuracy to 0.1: "+str(ACC1)+"%")
    print("Accuracy to 0.01: "+str(ACC01)+"%")
    print("Accuracy to 0.001: "+str(ACC001)+"%")
    print("\n\n")


##################
# Image parameters
##################
width = 100 # Image width
height = 100 # Image heigth
thickness = 5.0 # Line thickness

#################################
# Generate training and test data
#################################
num_train = 1000
num_test = 1000
test_images = []
test_angles = []
train_images = []
train_angles = []
for i in range(num_train):
    angle = pi*(2*rand() - 1)
    train_angles.append(angle)
    image = gen_train_image(angle,width,height,thickness)
    train_images.append(image)
for i in range(num_test):
    angle = pi*(2*rand() - 1)
    test_angles.append(angle)
    image = gen_train_image(angle,width,height,thickness)
    test_images.append(image)
train_angles,train_images,test_angles,test_images = array(train_angles),array(train_images),array(test_angles),array(test_images)



###########################
# Evaluate encoding schemes
###########################
num_iters = 50

# Train with cos,sin encoding
method = "cossin"
results1 = test_encoding_method(train_images, train_angles, test_images, test_angles, method, num_iters)
display_results(results1,method)

# Train with scaled encoding
method = "scaled"
results3 = test_encoding_method(train_images, train_angles, test_images, test_angles, method, num_iters)
display_results(results3,method)

# Train with binned encoding
method = "binned"
results2 = test_encoding_method(train_images, train_angles, test_images, test_angles, method, num_iters)
display_results(results2,method)

# Train with gaussian encoding
method = "gaussian"
results4 = test_encoding_method(train_images, train_angles, test_images, test_angles, method, num_iters)
display_results(results4,method)

Другой способ кодирования угла - это набор из двух значений:

у1 = макс (0, тета)

у2 = макс (0, -тета)

theta_out = y1 - y2

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