Conceptos de IA en Python

Neuronas y funciones de activación en Python

Una neurona artificial es una función diminuta. Multiplica cada entrada por un peso, suma un sesgo y pasa el resultado por una función de activación que decide con qué fuerza se «dispara».

El concepto en palabras sencillas

Una neurona artificial es una función diminuta. Multiplica cada entrada por un peso, suma un sesgo y pasa el resultado por una función de activación que decide con qué fuerza se «dispara».

Construye una neurona artificial en Python puro: una suma ponderada de las entradas más un sesgo, pasada por sigmoid o ReLU.

Ideas clave

Los pesos indican la importancia de cada entrada; el sesgo desplaza el resultado hacia arriba o hacia abajo.
Sin activación, apilar neuronas seguiría dando solo un modelo lineal (una recta).
Sigmoid devuelve un valor entre 0 y 1, por eso sirve para probabilidades.
ReLU es rápida y es la opción habitual en las capas ocultas de las redes modernas.

¿Cuándo se utiliza?

Entender qué pasa dentro de las redes neuronales y las bibliotecas de IA.
Aprender la idea antes de implementarla en los retos correspondientes.
Prepararte para cursos de aprendizaje automático, entrevistas y proyectos.

Pruébalo en acción

Mueve los controles para cambiar las entradas, los pesos y el sesgo. Observa cómo la suma ponderada z se desplaza por las curvas sigmoid y ReLU.

Código de ejemplo

Ejecutar código →

main.py

import math

# A neuron multiplies each input by a weight, adds them up and adds a bias.
def dot(a, b):
    return sum(x * y for x, y in zip(a, b))

def sigmoid(z):
    return 1 / (1 + math.exp(-z))   # squashes any number into (0, 1)

def relu(z):
    return max(0.0, z)              # keeps positives, turns negatives into 0

inputs = [0.5, -1.0, 2.0]
weights = [0.8, 0.2, -0.5]
bias = 0.1

z = dot(inputs, weights) + bias      # weighted sum
print("weighted sum z =", round(z, 3))
print("sigmoid(z) =", round(sigmoid(z), 3))
print("relu(z) =", relu(z))

# The activation decides how strongly the neuron "fires".
for value in [-2, 0, 2]:
    print(f"z={value:>2}  sigmoid={sigmoid(value):.3f}  relu={relu(value)}")

Resultado esperado

weighted sum z = -0.7
sigmoid(z) = 0.332
relu(z) = 0.0
z=-2  sigmoid=0.119  relu=0.0
z= 0  sigmoid=0.500  relu=0.0
z= 2  sigmoid=0.881  relu=2

Cómo funciona

dot() calcula la suma ponderada z. Sigmoid comprime z en un valor entre 0 y 1, mientras que ReLU conserva los valores positivos y convierte los negativos en 0. El bucle muestra cómo responde cada activación a una entrada negativa, cero y positiva.

Cambia los valores y ejecuta el programa en el compilador Python online de CodeUtility sin instalar Python.

Ejercicios prácticos

Modifica las entradas y prueba casos límite antes de usar conjuntos de datos mayores.

Cambia las entradas o los pesos y predice la salida antes de ejecutar.
Imprime los valores intermedios para seguir cada paso del cálculo.
Resuelve los retos enlazados abajo para implementar la idea por tu cuenta.

Ejecutar en el IDE de Python →

Practica con un reto

Usa lo que cubre esta lección para resolver un problema real. Cada reto se ejecuta en el navegador, con pruebas al instante y una revisión de IA.

Todos los retos