Neurona de McCulloch y Pitts programada en Python

Irving Vasquez
8 Mar 202412:59

Summary

TLDREn esta sesión educativa, el presentador, Irving Vázquez, guía a los espectadores a través del proceso de programación de la neurona de McCulloch-Pitts utilizando Python, comenzando por introducir el repositorio en GitHub donde se encuentran los programas del curso de introducción a las redes neuronales. Explica cómo cargar los notebooks en Colab y destaca la importancia de entender las bases de las redes neuronales sin depender completamente de librerías como Numpy. La sesión se centra en implementar y probar la neurona de McCulloch-Pitts, demostrando su funcionamiento con ejemplos prácticos y preparando a los espectadores para sesiones futuras sobre temas más avanzados como el perceptrón de Frank Rosenblatt.

Takeaways

  • 📚 Sesión de programación de la neurona de McCulloch-Pitts utilizando Python.
  • 🔍 Repositorio de Irving Vázquez en GitHub contiene programas relacionados con redes neuronales.
  • 💻 Para ejecutar los programas se requiere tener Python instalado tanto en Linux como en Windows.
  • 🌟 Se recomienda darle una 'Estrellita' al repositorio si es útil para aprender sobre redes neuronales.
  • 📝 El primer ejercicio es implementar la neurona de McCulloch-Pitts, la cual es una de las neuronas más antiguas.
  • 🧠 La neurona de McCulloch-Pitts tiene entradas excitatorias e inhibitorias y una salida binaria (1 o 0).
  • ✅ Seguidamente, se programa la neurona sin utilizar funciones predefinidas de numpy, empleando Python básico.
  • 🔢 Se define la función `neurona_mip` que toma como parámetros las entradas y el umbral.
  • 🚫 Si hay alguna entrada inhibitoria que sea 1, la neurona devuelve un 0.
  • 🔁 Se realiza una sumatoria de las entradas excitatorias y se compara con el umbral para decidir la salida.
  • 📈 Se prueba la función con diferentes conjuntos de entradas para verificar su comportamiento.
  • 📚 Se utilizan ejemplos del libro de Marvin Minsky para corroborar el funcionamiento de la neurona.

Q & A

  • ¿Qué es el repositorio de GitHub mencionado en el video y qué se puede encontrar en él?

    -El repositorio de GitHub mencionado por Irving Vázquez es un espacio donde los usuarios pueden encontrar programas relacionados con un curso de introducción a las redes neuronales, además de otros proyectos de investigación.

  • ¿Cuáles son las herramientas mencionadas que se necesitan para ejecutar los programas del curso?

    -Para ejecutar los programas del curso, se menciona el uso de Conda, que puede ser utilizado tanto en sistemas operativos Linux como Windows.

  • ¿Cómo se facilita a los estudiantes el uso de los notebooks en GitHub?

    -Irving Vázquez ha colocado un botón en la mayoría de los notebooks que permite cargarlos directamente en Google Colab, lo que simplifica significativamente el proceso de ejecución de los programas.

  • ¿Qué es una neurona de McCulloch-Pitts según el contenido del video?

    -La neurona de McCulloch-Pitts es un modelo conceptual de una neurona, propuesto en 1943, que opera basándose en entradas excitatorias e inhibitorias y produce una salida binaria de excitación o no excitación.

  • ¿Cuáles son las reglas básicas de funcionamiento de la neurona de McCulloch-Pitts mencionadas en el video?

    -La neurona de McCulloch-Pitts sigue dos reglas básicas: si hay una entrada inhibitoria activa (valor uno), la salida siempre será cero; si no hay entradas inhibitorias, la salida dependerá de si la suma de las entradas excitatorias supera un umbral específico.

  • ¿Qué función se necesita implementar en el notebook y qué parámetros recibe?

    -Se necesita implementar la función 'neurona_mip', que recibe las entradas excitatorias, las entradas inhibitorias y el umbral como parámetros para determinar la salida de la neurona según las reglas descritas.

  • ¿Cómo se realizan las pruebas de la función de la neurona de McCulloch-Pitts en el notebook?

    -En el notebook, se prueba la función 'neurona_mip' utilizando varios ejemplos que cambian los valores de las entradas excitatorias, las entradas inhibitorias y el umbral, para observar si la salida se comporta como se espera según las reglas de la neurona.

  • ¿Qué tipo de ejemplos se utilizan para probar el comportamiento de la neurona de McCulloch-Pitts?

    -Se utilizan ejemplos que simulan comportamientos lógicos básicos como NOT y OR, ajustando las entradas y el umbral para verificar si la neurona proporciona la salida correcta para cada caso lógico.

  • ¿Cuál es el propósito de no usar funciones predefinidas de Numpy en la implementación inicial de la neurona?

    -El propósito de evitar funciones predefinidas de Numpy es permitir a los estudiantes entender y codificar las operaciones básicas desde cero, lo que ayuda a una mejor comprensión de cómo funciona la neurona de McCulloch-Pitts a nivel fundamental.

  • ¿Qué sigue después de este tutorial sobre la neurona de McCulloch-Pitts según el video?

    -Después de este tutorial, la siguiente sesión cubrirá otros programas, incluyendo el perceptrón de Frank Rosenblatt, que es otro modelo importante en el estudio de las redes neuronales.

Outlines

00:00

😀 Introducción a la Neurona de McCulloch-Pitts

Se inicia la sesión con una presentación sobre la programación de la neurona de McCulloch-Pitts utilizando Python. Se menciona la utilización de GitHub para acceder a los programas del curso de redes neuronales y se destaca la importancia de este repositorio para encontrar material de investigación relacionado. Se ofrece la posibilidad de ejecutar los programas desde una computadora con Python instalado y se sugiere dejar un 'me gusta' en el repositorio si ha sido útil para aprender sobre redes neuronales. El primer ejercicio se enfoca en la implementación de la neurona de McCulloch-Pitts, la cual es considerada la más antigua y se describe brevemente su funcionamiento con entradas excitatorias e inhibitorias, resultando en una salida binaria (1 o 0). Se enfatiza el uso de Python para programar la neurona sin recurrir a funciones predefinidas de bibliotecas como numpy, optando por un enfoque más básico y educativo.

05:04

📝 Implementación de la Neurona de McCulloch-Pitts

Se describe el proceso de implementación de la neurona de McCulloch-Pitts en Python. Se establecen las reglas para la activación de la neurona: si hay al menos una entrada inhibitoria activa (valor 1), la neurona se desactiva (retorna 0). En caso contrario, se calcula la suma de las entradas excitatorias y se compara con un umbral. Si la suma es mayor o igual al umbral, la neurona activa (retorna 1); de lo contrario, se mantiene inactiva (retorna 0). Se detalla el código en Python para llevar a cabo estas operaciones, incluyendo la inicialización de variables y el uso de estructuras de control condicionales. Se sugiere probar la función con diferentes conjuntos de entradas para verificar su comportamiento, y se hace referencia a ejemplos del libro de Marvin Minsky para corroborar los resultados.

10:05

🤖 Comportamientos de la Neurona de McCulloch-Pitts

Se exploran diferentes comportamientos de la neurona de McCulloch-Pitts, como el operador lógico NOT y OR, aplicados a las entradas de la neurona. Se ejecutan pruebas con diferentes combinaciones de entradas excitatorias e inhibitorias y se ajusta el umbral para observar cómo cambia la salida de la neurona. Se confirma que la neurona reproduce correctamente los comportamientos lógicos esperados para operadores NOT y OR. Se menciona que en una próxima sesión se abordarán otros programas, incluyendo el perceptrón de Frank Rosenblatt, dejando al espectador expectante para la continuación del curso.

Mindmap

Keywords

💡Neuronas

Las neuronas son las unidades básicas del sistema nervioso que se encargan de transmitir información. En el contexto del video, se refiere a neuronas artificiales, que son modelos matemáticos inspirados en las neuronas biológicas y que son fundamentales en las redes neuronales.

💡Neuronas de McCulloch-Pitts

Las neuronas de McCulloch-Pitts son una de las primeras modelos teóricos de una neurona artificial. Consisten en una neurona que tiene entradas excitatorias e inhibitorias y produce una salida binaria (1 o 0) basada en un umbral. Son un concepto clave en la introducción al aprendizaje automático y las redes neuronales.

💡Python

Python es un lenguaje de programación de alto nivel ampliamente utilizado en la creación de aplicaciones de inteligencia artificial, incluyendo la programación de redes neuronales. En el video, se utiliza Python para implementar la neurona de McCulloch-Pitts.

💡GitHub

GitHub es una plataforma de desarrollo de software y alojamiento web para proyectos de código abierto y privada. En el video, se menciona GitHub como el lugar donde se encuentra el repositorio con los programas del curso de redes neuronales.

💡Colab

Colab (Google Colaboratory) es un servicio de Google que permite la escritura y ejecución de programas de Python en la nube. Se menciona en el video como una herramienta para abrir y utilizar los cuadernos (notebooks) relacionados con el curso.

💡Repositorio

Un repositorio en el contexto de programación y desarrollo de software es un directorio que contiene el código fuente de un proyecto, junto con su historial de revisiones. En el video, se habla de un repositorio específico en GitHub que contiene los materiales del curso.

💡Cuaderno de Jupyter

Un cuaderno de Jupyter (también conocido como notebook) es una herramienta de programación interactiva que permite la combinación de código, documentos y visualizaciones en un mismo lugar. En el video, se utilizan notebooks para ejecutar y compartir programas de redes neuronales.

💡Umbral

El umbral en el contexto de las neuronas de McCulloch-Pitts es el valor que determina si la neurona activa o no su salida. Si la suma de las entradas excitatorias supera el umbral, la neurona 'excitada' produce una salida de 1; de lo contrario, es 0.

💡Entradas excitatorias e inhibitorias

Las entradas excitatorias e inhibitorias son las señales que recibe una neurona artificial y que influyen en su decisión de activar o no su salida. En el video, se indica que cualquier entrada inhibitoria que sea 1 asegura que la salida de la neurona sea 0, mientras que las entradas excitatorias contribuyen a superar el umbral.

💡Implementación

La implementación en programación se refiere al proceso de crear un software o sistema que cumpla con un conjunto de requisitos específicos. En el video, se aborda la implementación de la neurona de McCulloch-Pitts usando Python, lo que implica escribir el código que define cómo la neurona funciona.

💡Lógica binaria

La lógica binaria es un sistema de numeración que utiliza solo dos símbolos: 0 y 1. Es fundamental en la informática y la electrónica, y en el video se utiliza para describir la salida de la neurona de McCulloch-Pitts, que es una representación binaria de excitación (1) o no excitación (0).

Highlights

Sesión de programación de la neurona de McCulloch-Pitts usando Python

Repositorio de GitHub de Irving Vázquez con programas del curso de redes neuronales

Ejecutar programas en computadora con Jupyter Notebook en Linux o Windows

Botón para cargar Notebook directamente en Google Colab

Dejar una estrella en el repositorio si es útil para aprender redes neuronales

Primer ejercicio: implementar la neurona de McCulloch-Pitts

Ejercicios en Jupyter Notebooks interactivos de Python

Si hay problemas, siempre se deja la solución del ejercicio

Neuronas de McCulloch-Pitts son la más antigua, datan de 1943

Tienen entradas excitatorias e inhibitorias y salida binaria (1 o 0)

Implementar neurona en Python sin usar funciones predefinidas de numpy

Cargar npai para asegurar que el usuario es responsable del código ejecutado

Función neurona_mip toma entradas y umbral, devuelve 1 (excitación) o 0

Si hay entrada inhibitoria = 1, neurona devuelve 0

Si no hay entradas inhibitorias, se calcula la suma de entradas excitatorias

Si suma >= umbral, neurona muestra excitación (1), sino es 0

Ejemplos de prueba: NOT (sin excitatorias, inhibitoria=0) da 1

Ejemplo OR: 2 excitatorias, umbral=1, da 1 si ambas son 1

Transcripts

play00:00

Hola Qué tal cómo están en esta sesión

play00:02

lo que vamos a hacer es programar la

play00:04

neurona de macac y pits para eso vamos a

play00:07

utilizar python y bueno primero les

play00:10

quiero mostrar En dónde está el

play00:11

repositorio para que ahí mismo puedan

play00:14

encontrar los siguientes programas del

play00:16

curso de introducción a las redes

play00:18

neuronales y nos tenemos que ir a

play00:23

github.com y diagonal Irving Vázquez

play00:26

entonces ahí está mi repositorio y ahí

play00:30

van a poder encontrar digamos diversos

play00:33

repositorios que tienen que ver con

play00:34

investigación que nosotros hacemos y

play00:36

sobre todo van a encontrar los programas

play00:39

relacionados al curso de interrupción a

play00:41

las redes

play00:42

neuronales así que pues bueno aquí ya

play00:46

aparece aquí dentro de los repositorios

play00:47

populares pero si no apareciera pues

play00:49

tenemos que ir a repositorios y Buscar

play00:52

intro nn in neural networks Entonces en

play00:57

este caso está aquí y bueno nosotros lo

play01:01

abrimos Okay y aquí está la serie de

play01:03

programas que están

play01:05

relacionadas relacionados con el curso

play01:09

de introducción a las redes

play01:10

neuronales primero para ejecutar estos

play01:13

programas lo pueden hacer desde su

play01:16

computadora para eso requieren cona y lo

play01:19

pueden hacer tanto en Linux como en

play01:21

Windows afortunadamente para ustedes ya

play01:25

coloqué aquí en cada uno en la mayoría

play01:28

de los notebooks eh un botoncito para

play01:32

que directamente lo carguen en su colap

play01:34

eso les va a facilitar la vida y si ya

play01:37

andan por acá pues no olviden dejar aquí

play01:39

por aquí un una Estrellita a este

play01:42

repositorio si es que les ayuda a

play01:44

prender redes neuronales okay

play01:48

Bueno entonces lo que vamos a hacer es

play01:51

el primer ejercicio está aquí en macac y

play01:53

pits es el que vamos a abrir ahorita

play01:56

Recuerden que pues yo siempre les dejo

play01:59

el ejercicio y les dejo la solución por

play02:01

si hubiera algún problema de Por qué no

play02:04

sé por alguna razón desconocida no

play02:07

pudieron resolver el ejercicio pues les

play02:09

dejo siempre arriba la solución en este

play02:12

primer ejercicio vamos a tratar de

play02:14

implementar la neurona de macac pits

play02:17

Entonces los ejercicios son los que

play02:20

tienen el I el python interactivo

play02:24

interactive python Notebook Entonces lo

play02:27

abrimos y Aquí está el Notebook Pues

play02:31

básicamente hay que resolver este

play02:32

ejercicio donde vamos a programar esta

play02:35

neurona que es digamos la más antigua y

play02:39

como les decía afortunadamente ya que

play02:42

tenemos este botoncito Y si ustedes ya

play02:44

tienen configurado su colaps con su

play02:46

cuenta de Google directamente van a

play02:50

poder abrir el Notebook en su cuenta de

play02:52

colaps esto ya les facilita bastante la

play02:55

vida y Bueno aquí ya estamos en el

play02:58

Notebook que vamos vamos a resolver

play03:01

Recuerden que si de repente tienen dudas

play03:03

con estos programas o o en el curso que

play03:05

tenemos en mi página pues este escribe a

play03:08

mí ahí un comentario en el video de

play03:09

YouTube y de vez en cuando pues checo

play03:13

checo los comentarios y les puedo dar

play03:15

respuesta Entonces vamos a ver

play03:20

em ya tenemos un video que nos explica

play03:23

de qué va esta neurona de macac pits que

play03:26

es la más antigua de ahí de 1900 40 43

play03:32

y bueno tiene como entradas dos cosas no

play03:36

recordemos las entradas inhibitorias y

play03:38

las entradas excitatorias eso va a tener

play03:41

como entradas y como salidas únicamente

play03:44

va a tener excitación o no excitación

play03:47

uno o cero Eso es lo que vamos a

play03:49

entregar y lo que queremos es

play03:51

implementar esta neurona utilizando

play03:54

python la idea de este programa es que

play03:57

pues podamos adentrarnos en las

play03:59

herramientas y no vamos a utilizar

play04:02

ahorita funciones predefinidas de numpy

play04:05

etcétera vamos a utilizar lo más básico

play04:08

que podamos tener para elaborar nuestro

play04:11

programa entonces eh básicamente

play04:14

únicamente vamos a hacer uso de

play04:17

npai le decimos que sí que nosotros nos

play04:20

hacemos responsables por lo que vamos a

play04:22

ejecutar

play04:24

verdad entonces ahorita solo Vamos a

play04:27

estar cargando npai y lo que tenemos que

play04:30

hacer es Eh Pues básicamente rellenar

play04:32

esta función que se llama neurona mip

play04:36

que recibe como parámetros las entradas

play04:40

excitatorias las entradas inhibitorias y

play04:43

el umbral y ahora lo que nosotros vamos

play04:46

a codificar

play04:47

es estas reglas que ya vimos en la

play04:51

lección entonces recordando pues tenemos

play04:55

dos reglas la primera es que si existe

play04:58

una una entrada inhibitoria que sea uno

play05:03

la neurona siempre nos va a retornar un

play05:08

cero Okay eso siempre va a pasar si

play05:12

resulta que no tenemos entradas Eh

play05:15

inhibitorias entonces la neurona sí

play05:18

puede

play05:19

procesar y entonces cuando procesa va a

play05:22

ser la sumatoria de todas las entradas

play05:25

excitatorias y entonces nos va a

play05:28

comparar esa sumat con el umbral

play05:30

entonces un es un comportamiento

play05:32

bastante sencillo y lo vamos a

play05:35

implementar Entonces vamos a implementar

play05:38

nuestra primera reglita y esta primera

play05:40

reglita tenemos que verificar todas

play05:42

nuestras entradas inhibitorias

play05:45

Okay como les decía pues para utilizar

play05:49

un comportamiento más sencillo pues

play05:52

vamos a hacer un recorrido de todas las

play05:55

entradas que pudiéramos tener en las

play05:57

inhibitorias

play05:58

no ini que serían las inhibitorias vamos

play06:01

a poner

play06:02

in

play06:04

I eso significa que pues vamos a ir en

play06:08

todas las las entradas que tengamos si

play06:11

no tenemos ninguna entrada Pues no va a

play06:14

haber tanto problema pues no no va a

play06:17

entrar en este for verdad Entonces vamos

play06:20

a buscar si esa entrada

play06:24

inhibitoria es

play06:27

un ahorita estamos codificando todo

play06:31

entonces si resulta que tenemos un uno

play06:33

pues entonces nuestra función de la

play06:36

neurona de macala y pits nos va a

play06:38

retornar un

play06:41

cero en caso de que no encontremos este

play06:45

una entrada inhibitoria así pues lo que

play06:47

tenemos que hacer es la sumatoria verdad

play06:50

podemos resolver de diferentes formas la

play06:52

la sumatoria pero en este caso pues les

play06:54

digo que yo lo que voy a

play06:57

usar pues es programación

play07:01

eh básica con una estructura de

play07:07

recorrido pues como tenemos que hacer

play07:09

una sumatoria pues vamos a poner

play07:15

integración esta integración Pues en un

play07:18

principio la vamos a igualar con cero y

play07:20

vamos a ir recorriendo pues cada una de

play07:24

nuestras entradas excitatorias Okay

play07:27

entonces vamos a poner e excitatorias in

play07:32

E eso vamos a hacer el recorrido en

play07:34

todas las

play07:37

excitatorias vamos a ir

play07:41

sumando y vamos a tener a integración es

play07:45

igual a integración más

play07:48

x OK Porque puede que resulte que no

play07:51

siempre tengamos entradas excitatorias

play07:54

igual con

play07:55

un y con eso ya básicamente tenemos

play07:59

nuestra

play08:00

sumatoria ahora tenemos que verificar

play08:02

con respecto del umbral Okay si resulta

play08:06

que la

play08:09

integración es mayor o igual que nuestro

play08:15

umbral entonces resulta que nuestra

play08:18

neurona sí va a mostrar un

play08:20

comportamiento

play08:22

excitatorio Entonces vamos a poner

play08:25

return 1 y si resulta que no pues vamos

play08:30

a

play08:32

regresar

play08:34

un cero

play08:36

verdad aquí nos falta

play08:39

If ahí está ahí ya está nuestro código

play08:42

que va a ser nuestra implementación de

play08:44

la neurona de macala pits muy rápido muy

play08:47

sencillo Ya hicimos este pequeño

play08:50

programita y ahora pues lo que vamos a

play08:51

hacer es probar

play08:54

Okay

play08:56

entonces aquí nos faltaron dos puntos

play09:00

Ahí está entonces vamos a ver qué es lo

play09:02

que va a pasar vamos a calcular la

play09:04

salida y vamos a imprimir

play09:07

print

play09:16

de neurona mip y lo que le vamos a pasar

play09:20

pues estos parámetros que ya tenemos

play09:22

aquí

play09:22

definidos la

play09:24

e de

play09:27

excitatorias la i que tenemos por acá y

play09:30

el

play09:33

umbral vamos a ver qué pasa si las

play09:36

excitatorias son uno y las inhibitorias

play09:40

son cer0 y tenemos un umbral igual con

play09:43

uno vamos a ver qué es lo que nos da

play09:45

Pues nos dice que el resultado es uno

play09:49

verdad Okay entonces para corroborar

play09:54

esto vamos a utilizar algunos ejemplos

play09:57

que tenemos en el libro de Marvin

play10:02

minsky y bueno de lado derecho estoy

play10:04

poniendo el libro de Marvin minsky y nos

play10:07

Define algunos comportamientos de estas

play10:10

neuronas de macac pits vamos a probar

play10:14

por ejemplo el not Okay el not significa

play10:21

que las entradas no tenemos entradas

play10:24

excitatorias

play10:26

verdad Y si tenemos un inhibitoria y el

play10:30

umbral es

play10:33

cero

play10:35

okay Entonces tenemos una inhibitoria

play10:37

qué va a pasar cuando la

play10:39

inhibitoria sea igual con cero la

play10:44

neurona nos debería dar un uno

play10:46

verdad y vamos a ejecutar esta celda y

play10:50

en efecto nos dice que la salida es uno

play10:55

si la inhibitoria es uno entonces la

play10:59

neurona nos debería decir que la salida

play11:01

es

play11:03

cero Entonces sí está mostrando el

play11:07

comportamiento del not ahora vamos a

play11:11

buscar otro comportamiento por ejemplo

play11:15

el or verdad vamos a probar con el or el

play11:18

or dice que tiene dos entradas no tiene

play11:21

inhibitorias está aquí en la parte de

play11:24

arriba no tiene

play11:26

inhibitorias pero tiene dos

play11:29

excitatorias Okay qué va a pasar cuando

play11:31

entrre dos excitatorias el cero y el

play11:34

cero vamos a

play11:36

ver entonces eso en un or nos debería

play11:39

dar

play11:40

cero y nos dio un

play11:46

uno Ah okay Claro porque no le cambiamos

play11:50

el umbral verdad ya estábamos dudando

play11:53

entonces dice que para el or el umbral

play11:55

es

play11:57

uno ahora sí entre 0 y o nos va a dar

play12:01

Qué pasa si entra a la neurona el 0 y el

play12:07

uno el resultado es uno okay estamos

play12:10

bien Luego sería el uno con el

play12:13

cero y eh podemos ver que nos da un

play12:18

uno y finalmente pues vamos a probar el

play12:21

uno con el uno debe dar uno no verá no

play12:24

dos ni nada raro Entonces tenemos que un

play12:28

uno okay Entonces ya este probamos esta

play12:31

neurona de macac pits con el not y la

play12:34

probamos con el or así que pues espero

play12:37

que les haya quedado igual que a mí y

play12:40

pues en la siguiente sesión vamos a

play12:42

hacer otros programas y entre ellos el

play12:44

perceptrón de Frank rosen blad así que

play12:49

pues bueno Pues nos estaremos viendo en

play12:51

esa siguiente sesión Espero que hayan

play12:53

hecho este programita al igual que yo

play12:55

hasta

play12:57

luego

Rate This

5.0 / 5 (0 votes)

Related Tags
NeuronasMcCulloch-PittsPythonTutorialRedes NeuronalesIntroductorioCódigoGitHubIrving VázquezInteractivoEjercicios
Do you need a summary in English?