Codificación de datos de ángulo para red neuronal

Estoy entrenando una red neuronal (los detalles no son importantes) donde los datos objetivo son un vector de ángulos (entre 0 y 2 * pi). Estoy buscando consejos sobre cómo codificar estos datos. Esto es lo que estoy intentando actualmente (con éxito limitado):

1) Codificación 1-de-C: pongo los ángulos posibles configurados en aproximadamente 1000 ángulos discretos y luego indico un ángulo particular poniendo un 1 en el índice relevante. El problema con esto es que la red simplemente aprende a generar todos los 0 (ya que esto es casi exactamente correcto).

2) Escalado simple: escalé el rango de salida de la red ([0,1]) a [0,2 * pi]. El problema aquí es que los ángulos tienen naturalmente una topología circular (es decir, 0.0001 y 2 * pi están realmente uno al lado del otro). Con este tipo de codificación, esa información se pierde.

¡Cualquier sugerencia sera apreciada!

Introducción

Encuentro esta pregunta realmente interesante, supongo que alguien ha publicado un documento sobre ella, pero es mi día libre, así que no quiero ir a buscar referencias.

Entonces podríamos considerarlo como una representación / codificación de la salida, lo que hago en esta respuesta. Sigo pensando que hay una mejor manera, donde puedes usar una función de pérdida ligeramente diferente. (Quizás la suma de las diferencias al cuadrado, utilizando el módulo de resta 2 ).$\pi$

Pero en adelante con la respuesta real.

Método

Propongo que un ángulo se represente como un par de valores, su seno y su coseno.$\theta$

Entonces, la función de codificación es: y la función de decodificación es: Para arctan2 siendo las tangentes inversas, preservando la dirección en todos los cuadrantes)$\qquad\qquad\quad\theta \mapsto (\sin(\theta), \cos(\theta))$
$\qquad(y_1,y_2) \mapsto \arctan\!2(y_1,y_2)$

_{En teoría, podría trabajar de manera equivalente directamente con los ángulos si su herramienta utiliza el soporte atan2como una función de capa (tomando exactamente 2 entradas y produciendo 1 salida). TensorFlow hace esto ahora y admite el descenso de gradiente en él , aunque no está destinado para este uso. Investigué el uso out = atan2(sigmoid(ylogit), sigmoid(xlogit)) con una función de pérdida min((pred - out)^2, (pred - out - 2pi)^2). Descubrí que entrenaba mucho peor que usar outs = tanh(ylogit), outc = tanh(xlogit)) con una función de pérdida 0.5((sin(pred) - outs)^2 + (cos(pred) - outc)^2. Lo cual creo que puede atribuirse a que el gradiente es discontinuo paraatan2}

Mi prueba aquí lo ejecuta como una función de preprocesamiento

Para evaluar esto, definí una tarea:

Dada una imagen en blanco y negro que representa una sola línea sobre un fondo en blanco, indique en qué ángulo se encuentra esa línea con el "eje x positivo"

Implementé una función para generar aleatoriamente estas imágenes, con líneas en ángulos aleatorios (NB: las versiones anteriores de esta publicación usaban pendientes aleatorias, en lugar de ángulos aleatorios. Gracias a @Ari Herman por señalarlo. Ahora está arreglado). Construí varias redes neuronales para evaluar su desempeño en la tarea. Los detalles completos de la implementación se encuentran en este cuaderno Jupyter . El código está todo en Julia , y uso la biblioteca de red neuronal Mocha .

A modo de comparación, lo presento contra los métodos alternativos de escalado a 0,1. y para poner en 500 contenedores y usar softmax de etiqueta blanda. No estoy particularmente contento con el último, y siento que necesito modificarlo. Es por eso que, a diferencia de los otros, solo lo pruebo por 1,000 iteraciones, frente a los otros dos que se ejecutaron por 1,000 y por 10,000

Configuración experimental

Las imágenes eran píxeles, con la línea en el centro y hacia el borde. No había ruido, etc. en la imagen, solo una línea "negra", sobre un fondo blanco.$101\times101$

Para cada recorrido, se generaron 1,000 entrenamientos y 1,000 imágenes de prueba al azar.

La red de evaluación tenía una sola capa oculta de ancho 500. Se usaron neuronas sigmoideas en la capa oculta.

Fue entrenado por Stochastic Gradient Decent, con una tasa de aprendizaje fija de 0.01 y un impulso fijo de 0.9.

No se usó regularización o abandono. Tampoco hubo ningún tipo de convolución, etc. Una red simple, que espero sugiera que estos resultados se generalizarán

Es muy fácil modificar estos parámetros en el código de prueba , y animo a las personas a que lo hagan. (y busca errores en la prueba).

Resultados

Mis resultados son los siguientes:

|                        |  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%       |

Cuando me refiero al error, este es el valor absoluto de la diferencia entre el ángulo de salida de la red neuronal y el ángulo verdadero. Entonces, el error medio (por ejemplo) es el promedio sobre los 1,000 casos de prueba de esta diferencia, etc. No estoy seguro de que no deba volver a escalarlo haciendo un error de decir ser igual a un error de ).$\frac{7\pi}{4}$$\frac{\pi}{4}$

También presento la precisión en varios niveles de granularidad. La precisión es la parte de los casos de prueba que se corrigió. Entonces accuracy_to_point01significa que se contó como correcto si la salida estaba dentro de 0.01 del ángulo verdadero. Ninguna de las representaciones obtuvo resultados perfectos, pero eso no es sorprendente dado el funcionamiento de las matemáticas de coma flotante.

Si echas un vistazo al historial de esta publicación, verás que los resultados tienen un poco de ruido, ligeramente diferente cada vez que lo vuelvo a ejecutar. Pero el orden general y la escala de valores siguen siendo los mismos; lo que nos permite sacar algunas conclusiones.

Discusión

Binning con softmax es, con mucho, el peor, ya que dije que no estoy seguro de no haber estropeado algo en la implementación. Sin embargo, funciona marginalmente por encima de la tasa de conjetura. si solo estuviera adivinando, obtendríamos un error medio de$\pi$

La codificación sin / cos funciona significativamente mejor que la codificación 0-1 escalada. La mejora es en la medida en que con 1,000 iteraciones de entrenamiento, sin / cos se está desempeñando aproximadamente 3 veces mejor en la mayoría de las métricas que la escala en 10,000 iteraciones.

Creo que, en parte, esto está relacionado con la mejora de la generalización, ya que ambos obtuvieron un error cuadrático medio bastante similar en el conjunto de entrenamiento, al menos una vez que se ejecutaron 10,000 iteraciones.

Ciertamente, existe un límite superior para el mejor rendimiento posible en esta tarea, dado que el ángulo puede ser más o menos cualquier número real, pero no todos esos ángeles producen líneas diferentes con una resolución de píxeles. Entonces, dado que, por ejemplo, los ángulos 45.0 y 45.0000001 están vinculados a la misma imagen con esa resolución, ningún método obtendrá ambos perfectamente correctos.$101\times101$

También parece probable que en una escala absoluta para ir más allá de este rendimiento, se necesite una mejor red neuronal. En lugar del muy simple descrito anteriormente en la configuración experimental.

Conclusión.

Parece que la representación sin / cos es, con mucho, la mejor de las representaciones que investigué aquí. Esto tiene sentido, ya que tiene un valor uniforme a medida que te mueves alrededor del círculo. También me gusta que lo inverso se pueda hacer con arctan2 , que es elegante.

Creo que la tarea presentada es suficiente en su capacidad para presentar un desafío razonable para la red. Aunque supongo que realmente está aprendiendo a hacer un ajuste de curva para así que tal vez sea demasiado fácil. Y quizás peor, puede estar favoreciendo la representación pareada. No creo que sea así, pero se está haciendo tarde aquí, así que podría haber perdido algo. Te invito nuevamente a que revises mi código . Sugerir mejoras o tareas alternativas.$f(x)=\frac{y1}{y2} x$

Aquí hay otra implementación de Python que compara la codificación propuesta de Lyndon White con un enfoque agrupado. El siguiente código produjo el siguiente resultado:

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

Como puede ver, mientras que el enfoque agrupado se desempeña admirablemente en esta tarea de juguete, la codificación funciona mejor en todas las configuraciones de entrenamiento, a veces por un margen considerable. Sospecho que la tarea específica se hizo más compleja, los beneficios del uso de Lyndon blanca 's representación sería más pronunciada.( sin ( θ ) , cos ( θ ) $(\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()

Aquí está mi versión de Python de tu experimento. Mantuve muchos de los detalles de su implementación igual, en particular uso el mismo tamaño de imagen, tamaños de capa de red, tasa de aprendizaje, impulso y métricas de éxito.

Cada red probada tiene una capa oculta (tamaño = 500) con neuronas logísticas. Las neuronas de salida son lineales o softmax como se señaló. Usé 1,000 imágenes de entrenamiento y 1,000 imágenes de prueba que se generaron de forma independiente y aleatoria (por lo que puede haber repeticiones). El entrenamiento consistió en 50 iteraciones a través del conjunto de entrenamiento.

Pude obtener una precisión bastante buena usando binning y codificación "gaussiana" (un nombre que inventé; similar a binning excepto que el vector de salida de destino tiene la forma exp (-pi * ([1,2,3, ... , 500] - idx) ** 2) donde idx es el índice correspondiente al ángulo correcto). El código está abajo; Aquí están mis resultados:

Error de prueba para codificación (cos, sin):

1,000 imágenes de entrenamiento, 1,000 imágenes de prueba, 50 iteraciones, salida lineal

• Media: 0.0911558142071

• Mediana: 0.0429723541743

• Mínimo: 2.77769843793e-06

• Máximo: 6.2608513539

• Precisión a 0.1: 85.2%

• Precisión a 0.01: 11.6%

• Precisión hasta 0.001: 1.0%

Error de prueba para la codificación [-1,1]:

1,000 imágenes de entrenamiento, 1,000 imágenes de prueba, 50 iteraciones, salida lineal

• Media: 0.234181700523

• Mediana: 0.17460197307

• Mínimo: 0.000473665840258

• Máximo: 6.00637777237

• Precisión a 0.1: 29.9%

• Precisión a 0.01: 3.3%

• Precisión hasta 0.001: 0.1%

Error de prueba para codificación 1 de 500:

1,000 imágenes de entrenamiento, 1,000 imágenes de prueba, 50 iteraciones, salida softmax

• Media: 0.0298767021922

• Mediana: 0.00388858079174

• Mínimo: 4.08712407829e-06

• Máximo: 6.2784479965

• Precisión a 0.1: 99.6%

• Precisión a 0.01: 88.9%

• Precisión hasta 0.001: 13.5%

Error de prueba para codificación gaussiana:

1,000 imágenes de entrenamiento, 1,000 imágenes de prueba, 50 iteraciones, salida softmax

• Media: 0.0296905377463
• Mediana: 0.00365867335107
• Mínimo: 4.08712407829e-06
• Máximo: 6.2784479965
• Precisión a 0.1: 99.6%
• Precisión a 0.01: 90.8%
• Precisión hasta 0.001: 14.3%

No puedo entender por qué nuestros resultados parecen estar en contradicción entre sí, pero parece que vale la pena seguir investigando.

# -*- 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)

Otra forma de codificar el ángulo es como un conjunto de dos valores:

y1 = max (0, theta)

y2 = max (0, -theta)

theta_out = y1 - y2

Esto tendría el problema similar a arctan2 en que el gradiente no está definido en theta = 0. No tengo tiempo para entrenar una red y compararla con las otras codificaciones, pero en este artículo la técnica parecía razonablemente exitosa.