¿Cuáles son algunos ejemplos de redes neuronales en Python? La tecnología cambia la vida futura

Si está buscando un ejemplo de una red neuronal implementada en python (+ numpy), entonces tengo una implementación muy simple y básica que utilicé en un curso de ML reciente para realizar la clasificación en MNIST.

Si está buscando una biblioteca, entonces agregaría PyBrain a la lista de Renaud Richardets.

# codificación: utf-8

importar numpy como np

# configuración

HIDDEN_SIZE = 100
LEARNING_RATE = 0.0001
PERCENT_OF_VALIDATION_DATA = 10
MAX_NUMBER_OF_EPOCHS = 10
RANDOM_SEED = 0

clase Net (objeto):
“” ”
Red neuronal simple para clasificación. No usa sesgos.
TODO: guardar y cargar los parámetros del modelo.
“” ”

def __init __ (self, input_size, hidden_size, output_size, learning_rate):
super (Net, self) .__ init __ ()
self.learning_rate = learning_rate

self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size

self.W1 = np.random.uniform (bajo = -0.01, alto = 0.01, tamaño = (input_size, hidden_size))
self.W2 = np.random.uniform (low = -0.01, high = 0.01, size = (hidden_size, output_size))

def adelante (auto, x):
“” ”
Entradas:
x – vector de entrada
Devoluciones:
y1, y2: estados de capa ocultos y de salida
“” ”
z1 = np.dot (x, self.W1)
y1 = 1. / (1. + np.exp (-z1)) # sigmoide logístico

z2 = np.dot (y1, self.W2)
y2 = np.exp (z2 – z2.max ()) # softmax
y2 / = y2.sum () # softmax continuación

devuelve y1, y2

def hacia atrás (self, x, t, y1, y2):
“” ”
Entradas:
x – vector de entrada
t – vector objetivo
y1 – estado de capa oculta
y2 – estado de la capa de salida
Devoluciones:
dE_dW1, dE_dW2 – derivados de error (gradientes) con respecto a W1 y W2
“” ”
dE_dW1 = xTdot ((y2 – t) .dot (self.W2.T) * y1 * (1. – y1))
dE_dW2 = y1.T.dot (y2 – t)

devuelve dE_dW1, dE_dW2

actualización de def (self, dE_dW1, dE_dW2):
“” ”
Entradas:
dE_dW1 – derivada de error (gradiente) con respecto a W1
dE_dW2 – derivada de error (gradiente) con respecto a W2
“” ”
self.W1 – = self.learning_rate * dE_dW1
self.W2 – = self.learning_rate * dE_dW2

error de def (self, y2, t):
“” ”
Entradas:
y2 – estado de la capa de salida
t – vector objetivo
Devoluciones:
E – Error de entropía cruzada
“” ”
E = -np.sum (t * np.log (y2))
volver E

def vectorize_input (entrada):
“” ”
Aplana la matriz de entrada en un vector de fila
“” ”
return input.flatten () [np.newaxis]

def vectorize_target (size, target_index):
“” ”
Convierte el índice de destino en un vector de fila de un tamaño determinado.
“” ”
t = np.zeros (forma = (1, tamaño))
t [:, índice_destino] = 1.
volver t

def process_data (neto, entradas, objetivos, do_training = False):
“” ”
¿Se pasa por alto los pares de entrada-destino dados?
Puede ser utilizado para entrenamiento, validación y prueba.
“” ”
errores = []
total = 0
correcto = 0

para input, target_index en zip (entradas, objetivos):

x = vectorize_input (entrada)
t = vectorize_target (net.output_size, target_index)

y1, y2 = avance neto (x)

errors.append (net.error (y2, t))
total + = 1
correcto + = t [:, np.argmax (y2)]

if do_training:
dE_dW1, dE_dW2 = net.backward (x, t, y1, y2)
net.update (dE_dW1, dE_dW2)

error_medio = np.mean (errores)
print “Error de entropía cruzada promedio:% .2f; precisión:% .2f %%”% (error_medio, correcto / total * 100.)
return average_error

def backpropagation_is_correct (net):
“” ”
Comprueba gradientes de diferencias finitas contra los gradientes calculados por retropropagación
“” ”

tiny = 1e-4 # pequeña constante
x = np.random.uniform (tamaño = (1, net.input_size))
t = vectorize_target (size = net.output_size, target_index = np.random.randint (net.output_size))

y1, y2 = avance neto (x)
dE_dW1, dE_dW2 = net.backward (x, t, y1, y2)

errores = 0

para nombre, W, dE_dW en zip ((“W1”, “W2”), (net.W1, net.W2), (dE_dW1, dE_dW2)):

# verifique algunos (máximo 10) elementos aleatorios de W
para _ en rango (min (10, np.prod (W.shape))):

i = np.random.randint (W.shape [0])
j = np.random.randint (W.shape [1])

W [i, j] + = pequeño
y1, y2 = avance neto (x)
E_plus = net.error (y2, t)

W [i, j] – = 2. * pequeño
y1, y2 = avance neto (x)
E_minus = net.error (y2, t)

W [i, j] + = pequeño # volver al original

dE_dW_ij_numerical = (E_plus – E_minus) / (2. * pequeño)

si no np.allclose (dE_dW_ij_numerical, dE_dW [i, j]):
print “El gradiente para% s [% d,% d] no coincide (% f! =% f)” \
% (nombre, i, j, dE_dW_ij_numerical, dE_dW [i, j])
errores + = 1

errores de retorno == 0

def train (net, train_input, train_target, validation_input, validation_target):

para época en rango (1, MAX_NUMBER_OF_EPOCHS + 1):

print “\ nEpoch:% d”% epoch

imprimir “ENTRENAMIENTO:”
process_data (net, train_input, train_target, do_training = True)

imprimir “VALIDACIÓN:”
process_data (net, validation_input, validation_target)

prueba de definición (net, test_input, test_target):

imprimir “\ n PRUEBA:”
process_data (net, test_input, test_target)

if __name__ == “__main__”:

np.random.seed (RANDOM_SEED)

test_input = np.load (‘data / test-images.npy’) # Esto es solo el conjunto de datos MNIST, convertido a una matriz numpy, una imagen por fila.
test_target = np.load (‘data / test-labels.npy’) # Índices de clase de destino (0, 6, 0, 1, …)

train_input = np.load (‘data / train-images.npy’)
train_target = np.load (‘data / train-labels.npy’)

num_of_validation_samples = int (len (train_input) * PERCENT_OF_VALIDATION_DATA / 100)
num_classes = max (train_target) + 1 # las etiquetas comienzan desde 0
num_inputs = np.prod (train_input [0] .shape) # Número total de píxeles por imagen

validation_input, train_input = np.split (train_input, [num_of_validation_samples])
validation_target, train_target = np.split (train_target, [num_of_validation_samples])

net = Net (
input_size = num_inputs,
hidden_size = HIDDEN_SIZE,
output_size = num_classes,
learning_rate = LEARNING_RATE)

si no es backpropagation_is_correct (net):
raise Exception (“Parece que hay un problema con los gradientes”)

train (net, train_input, train_target, validation_input, validation_target)
prueba (net, test_input, test_target)