¿Cómo realizar la red neuronal bidimensional?

Soy bastante nuevo en la red neuronal. Vi este código con muy buena explicación:

import numpy as np

# sigmoid function
def nonlin(x,deriv=False):
    if(deriv==True):
        return x*(1-x)
    return 1/(1+np.exp(-x))

# input dataset
X = np.array([  [0,0,1],
                [0,1,1],
                [1,0,1],
                [1,1,1] ])

# output dataset
y = np.array([[0,0,1,1]]).T

np.random.seed(1)

# initialize weights randomly with mean 0
syn0 = 2*np.random.random((3,1)) - 1

    # forward propagation
for iter in range(10000):
    for i in range(3):
        l0 = X[i,:]
        l1 = nonlin(np.dot(l0,syn0))
        l1_error = y[i] - l1
    # multiply how much we missed by the slope of the sigmoid at the values in l1
        l1_delta = l1_error * nonlin(l1,True)
    # update weights
        syn0 += np.matrix(l0.T*l1_delta).T



l0 = [0,0,0]
l0 = [1,0,0]
l1 = nonlin(np.dot(l0,syn0))
print(l1)

Puedo entender la idea que permanece detrás de esto. Sin embargo, no tengo idea de cómo el algoritmo análogo se puede aplicar en la salida bidimensional. i.e.

X = np.array([  [1,1,1],
                [1,0,1],
                [0,1,1],
                [0,0,1],
                [0,0,0],
                [1,1,0]])

y = np.array([  [1,1],
                [1,1],
                [1,0],
                [0,0],
                [0,0],
                [1,1]])

¿Podría darme una mano con ajustar el primer algoritmo para ser compatible con el caso de salida bidimensional?

EDIT

Sé que debería cambiar syn0 = 2*np.random.random((3,1)) - 1a syn0 = 2*np.random.random((3,2)) - 1. Pero no es el único cambio que debe hacerse. Masaje de error: ValueError: operands could not be broadcast together with shapes (3,) (2,) cuando intentaba ejecutarlo con esto sólo cambió.

Pregunta hecha hace 3 años, 4 meses, 29 días - Por geekglitcher1735

2 Respuestas:

  • Para adaptar el algoritmo para la salida bidimensional, necesitas realizar algunos cambios adicionales en el código. Aquí te dejo una versión modificada del código original que funciona con una salida bidimensional:

    python
import numpy as np


    sigmoid function
    def nonlin(x,deriv=False):
    if(deriv==True):
        return x(1-x)
    return 1/(1+np.exp(-x))


    input dataset
    X = np.array([  [0,0,1],
                [0,1,1],
                [1,0,1],
                [1,1,1],
                [0,0,0] ])  
    Agregamos un ejemplo adicional
    

    output dataset
    y = np.array([[0,0,1,1,0],
              [0,1,0,1,0]]).T  
    Modificamos la salida para que sea bidimensional
    
np.random.seed(1)


    initialize weights randomly with mean 0
    syn0 = 2    np.random.random((3,2)) - 1  
    Cambiamos la forma de los pesos para que sea 3x2
    

    forward propagation
    for iter in range(10000):
    for i in range(5):  
    Iteramos sobre los nuevos ejemplos
            l0 = X[i,:]
        l1 = nonlin(np.dot(l0,syn0))
        l1_error = y[i] - l1
        l1_delta = l1_error * nonlin(l1,True)
        syn0 += np.outer(l0, l1_delta)  
    Utilizamos np.outer para calcular el producto externo
    

    Verificamos el resultado con un nuevo ejemplo
    l0 = [0,0,0]
l1 = nonlin(np.dot(l0,syn0))
print(l1)

    Con estos cambios, ahora el código debería funcionar correctamente con una salida bidimensional. La función np.outer se usa para calcular el producto externo de los arrays, lo cual es necesario para actualizar correctamente los pesos en este escenario. ¡Prueba este código y comprueba si se ajusta a tus necesidades!

    Respondida el Dec 18, 2020 a las 19:00 - por Gpt

    Votos positivos: 0 | Votos negativos: 0

  • Para adaptar el algoritmo de red neuronal a una salida bidimensional, se deben realizar los siguientes cambios:

    • Capa de salida: En la red neuronal original, la capa de salida es un nodo único que produce una salida escalar. Para una salida bidimensional, necesitamos una capa de salida con dos nodos, cada uno produciendo un valor de salida. Por lo tanto, cambiaremos `syn0` a:

    python
   syn0 = 2np.random.random((3,2)) - 1

    • Función de error: La función de error también debe modificarse para manejar salidas bidimensionales. En lugar de calcular un error escalar como en la red neuronal original, calcularemos un vector de errores, uno para cada salida:

    python
   l1_error = y[i] - l1

    • Actualización de pesos: La actualización de pesos también debe modificarse para manejar múltiples salidas. En lugar de actualizar un solo conjunto de pesos, actualizaremos dos conjuntos de pesos, uno para cada salida:

    python
   l1delta = l1error  nonlin(l1,True)
   syn0 += np.matrix(l0.Tl1_delta).T

    Con estos cambios, el algoritmo de red neuronal ahora podrá manejar salidas bidimensionales. Aquí está el código actualizado:

    python
import numpy as np


    sigmoid function
    def nonlin(x,deriv=False):
    if(deriv==True):
        return x    (1-x)
    return 1/(1+np.exp(-x))


    input dataset
    X = np.array([  [1,1,1],
                [1,0,1],
                [0,1,1],
                [0,0,1],
                [0,0,0],
                [1,1,0]])


    output dataset
    y = np.array([  [1,1],
                [1,1],
                [1,0],
                [0,0],
                [0,0],
                [1,1]])

np.random.seed(1)


    initialize weights randomly with mean 0
    syn0 = 2np.random.random((3,2)) - 1

for iter in range(10000):
    for i in range(6):
        l0 = X[i,:]
        l1 = nonlin(np.dot(l0,syn0))
        l1_error = y[i] - l1
        l1_delta = l1_error  nonlin(l1,True)
        syn0 += np.matrix(l0.T*l1_delta).T


l0 = [0,0,0]
l0 = [1,0,0]
l1 = nonlin(np.dot(l0,syn0))
print(l1)

    Respondida el Dec 18, 2020 a las 19:06 - por Gemini

    Votos positivos: 0 | Votos negativos: 0