¡Hola a todos! Recientemente, he estado gastando cantidades no-triviales de tiempo en el tema fascinante de la inteligencia artificial. ¡Ha llegado un largo camino! Con la liberación de Midjourney y ChatGPT, entre otros productos, 2023 parece ser extremadamente prometedor, incluso revolucionario. Me gustaría recomendar el siguiente tutorial: https://realpython.com/python-ai-neural-network/Es simple, suficientemente detallado, no utiliza el flujo de tensor, y produce una imagen al final! El código completo para ejecutar el ejemplo se reproduce a continuación:

importación matplotlib.pyplot as plt
importación numpy como np

Clase NeuralNetwork:
def __init__(self, learning_rate):
auto.weights = np.array([np.random.randn(), np.random.randn()])
self.bias = np.random.randn()
self.learning_rate = learning_rate

def _sigmoid(self, x):
retorno 1 / (1 + np.exp(-x))

def _sigmoid_deriv(self, x):
volver a sí mismo._sigmoid(x) * (1 - self._sigmoid(x))

def predict(self, input_vector):
layer_1 = np.dot(input_vector, self.weights) + self.bias
layer_2 = self._sigmoid(layer_1)
predicción = capa_2
predicción de retorno

def _compute_gradients(self, input_vector, target):
layer_1 = np.dot(input_vector, self.weights) + self.bias
layer_2 = self._sigmoid(layer_1)
predicción = capa_2

derror_dprediction = 2 * (prediction - target)
dprediction_dlayer1 = self._sigmoid_deriv(layer_1)
dlayer1_dbias = 1
dlayer1_dweights = (0 * auto.weights) + (1 * input_vector)

derror_dbias =
derror_dprediction * dprediction_dlayer1 * dlayer1_dbias
)
derror_dweights = (
derror_dprediction * dprediction_dlayer1 * Dlayer1_dweights
)

retorno derror_dbias, derror_dweights

def _update_parameters(self, derror_dbias, derror_dweights):
self.bias = self.bias - (derror_dbias * self.learning_rate)
auto.pesos = auto.pesos - (
derror_dweights * self.learning_rate
)

def train(self, input_vectors, targets, iterations):
cumulative_errors = []
for current_iteration in range(iterations):
# Elige una instancia de datos al azar
random_data_index = np.random.randint(len(input_vectors))

input_vector = input_vectors[random_data_index]
target = targets[random_data_index]

# Computar los gradientes y actualizar los pesos
derror_dbias, derror_dweights = self._compute_gradients(
input_vector, target
)

auto._update_parameters(derror_dbias, derror_dweights)

# Medir el error acumulativo para todos los casos
si actual_iteración % 100 == 0:
cumulative_error = 0
# Loop through all the instances to measure the error
para data_instance_index in range(len(input_vectors)):
data_point = input_vectors[data_instance_index]
target = targets[data_instance_index]

predicción = autopredicto(data_punto)
error = np.square(prediction - target)

cumulative_error = cumulative_error + error
cumulative_errors.append(cumulative_error)

regreso acumulativo_errores


input_vectors = np.array(
[
[3, 1.5],
[2, 1],
[4, 1.5],
[3, 4],
[3.5, 0.5],
[2, 0.5],
[5.5, 1],
[1, 1],
]
)

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

learning_rate = 0,01
neural_network = NeuralNetwork(learning_rate)

training_error = neural_network.train(input_vectors, targets, 1000)

plt.plot(training_error)
plt.xlabel("Iterations")
plt.ylabel("Error para todas las instancias de entrenamiento")
plt.savefig("cumulative_error.png")

Y me gustaría añadir un comentario propio a este gran tutorial. En primer lugar, el autor escribe el error resultante después del entrenamiento no disminuye porque el conjunto de datos es pequeño, sólo 8 puntos de datos: Pero, por supuesto, un estudiante astuto notaría que al disminuir la tasa de aprendizaje y aumentar el número de iteraciones de aprendizaje, podemos reducir ligeramente el error. O si no reduce el error, al menos reduce la diferencia del error. Lo siguiente es la trama de error después de disminuir la tasa de aprendizaje en 10 veces, y aumentar las iteraciones en 3 veces: Si nos acercamos, el error original se ve así, donde más pequeño es mejor: Así que puede ver los efectos de reducir la tasa de aprendizaje en el error. Mi segundo comentario es: ¿qué significa todo esto? Vamos a trazar los datos de entrada: Los rojos son vectores que deben clasificarse como "0", verdes se clasifican como "1". Azul es el vector que representa los pesos aprendidos de la red (hay sólo dos, por lo que los trazo como x,y). Los humanos son grandes en el reconocimiento del patrón. Sólo mirando la trama, se puede ver que el mejor (si overfit) predictor de estos datos sería un vector apuntando al promedio de flechas rojas, y una función de activación para especificar el radio alrededor del punto promedio, para definir el cluster rojo. Por supuesto, la ventaja de una red neuronal es que es capaz de clasificar (y realizar otras operaciones) en datos mucho más complejos, donde la trama de insumos quizás sería imposible. Sin embargo, para un tutorial introductorio, creo que trazar entradas y salidas, siempre que sea posible, es una buena manera de desarrollar la intuición sobre conceptos matemáticos. En un próximo artículo, vamos a entrar en detalles sobre varios tipos de ANN, y escribir un poco más de implementación de conceptos.