> For the complete documentation index, see [llms.txt](https://red-neuronal-artificial.gitbook.io/neuronas/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://red-neuronal-artificial.gitbook.io/neuronas/contenido/1.-introduccion-a-las-redes-neuronales./1.1-arquitectura-de-una-neurona-artificial/perceptron/programando-un-perceptron.md).
# Programando un perceptrón
Si deseas construir un perceptrón para la compuerta lógica AND, aquí te presento los pasos que puedes seguir:
1. Define las entradas y las salidas deseadas: En el caso de la compuerta AND, tienes dos entradas binarias (0 y 1) y una salida binaria que representa el resultado de la operación **AND**.
| Entrada 1 | Entrada 2 | Salida deseada |
| --------- | --------- | -------------- |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
2. Inicializa los pesos: Para la compuerta AND, necesitas dos pesos (w1 y w2) para las dos entradas respectivas. Puedes asignar valores aleatorios a los pesos para comenzar el proceso de entrenamiento.
3. Define la función de activación: En el caso de la compuerta AND, puedes utilizar la función de activación escalón. Esta función devuelve 1 si la sumatoria de las entradas ponderadas por los pesos es mayor o igual a 0, y devuelve 0 en caso contrario.
4. Calcula la sumatoria: Multiplica cada entrada por su peso correspondiente y luego suma los productos. Este resultado se utiliza como entrada para la función de activación.
5. Aplica la función de activación: Utiliza el resultado de la sumatoria y aplica la función de activación para obtener la salida del perceptrón.
6. Calcula el error: Compara la salida obtenida con la salida deseada y calcula el error. En el caso de la compuerta AND, puedes restar la salida deseada de la salida obtenida.
7. Actualiza los pesos: Utiliza el error calculado para actualizar los pesos. Puedes utilizar la regla de aprendizaje del perceptrón, que consiste en ajustar los pesos según la fórmula: nuevo peso = peso actual + tasa de aprendizaje \* error \* entrada.
8. Repite los pasos 4 a 7 para todas las combinaciones de entradas hasta que el perceptrón alcance un nivel de precisión aceptable.
Este es un enfoque básico para construir un perceptrón para la compuerta lógica AND. Sin embargo, hay diversas formas de implementarlo en diferentes lenguajes de programación, como Python.
### Ejemplo paso a paso de cómo resolver el problema de la compuerta lógica AND utilizando un perceptrón:
Define las entradas y salidas deseadas:
```python
entradas = [[0, 0],
[0, 1],
[1, 0],
[1, 1]]
salidas_deseadas = [0, 0, 0, 1]
```
Inicializa los pesos:
```python
w1 = 0.5
w2 = 0.5
```
Define la función de activación:
```python
def activacion(valor):
return 1 if valor >= 0 else 0
```
Calcula la sumatoria y aplica la función de activación:
```python
for i in range(len(entradas)):
entrada = entradas[i]
sumatoria = w1 * entrada[0] + w2 * entrada[1]
salida = activacion(sumatoria)
print(f"Entrada: {entrada} | Salida: {salida}")
```
Resultado:
```python
Entrada: [0, 0] | Salida: 0
Entrada: [0, 1] | Salida: 0
Entrada: [1, 0] | Salida: 0
Entrada: [1, 1] | Salida: 1
```
Calcula el error y actualiza los pesos:
```python
tasa_aprendizaje = 0.1
for i in range(len(entradas)):
entrada = entradas[i]
sumatoria = w1 * entrada[0] + w2 * entrada[1]
salida = activacion(sumatoria)
error = salidas_deseadas[i] - salida
w1 += tasa_aprendizaje * error * entrada[0]
w2 += tasa_aprendizaje * error * entrada[1]
```
1. Repite los pasos 4 y 5 varias veces (iteraciones) hasta obtener la salida deseada para todas las entradas.
Este es un ejemplo básico de cómo resolver el problema de la compuerta lógica AND utilizando un perceptrón de una capa. Cabe mencionar que este es un enfoque simple y que existen muchas variaciones y mejoras posibles, como el uso de una función de activación más sofisticada o el entrenamiento en lotes (batch training).
### Scrip completo:
{% code fullWidth="true" %}
```python
# Definir las entradas y salidas deseadas
entradas = [[0, 0],
[0, 1],
[1, 0],
[1, 1]]
salidas_deseadas = [0, 0, 0, 1]
# Inicializar los pesos
w1 = 0.5
w2 = 0.5
# Definir la función de activación
def activacion(valor):
return 1 if valor >= 0 else 0
# Definir la tasa de aprendizaje
tasa_aprendizaje = 0.1
# Entrenar el perceptrón
iteraciones = 10
for _ in range(iteraciones):
for i in range(len(entradas)):
entrada = entradas[i]
salida_deseada = salidas_deseadas[i]
# Calcular la sumatoria y aplicar la función de activación
sumatoria = w1 * entrada[0] + w2 * entrada[1]
salida = activacion(sumatoria)
# Calcular el error y actualizar los pesos
error = salida_deseada - salida
w1 += tasa_aprendizaje * error * entrada[0]
w2 += tasa_aprendizaje * error * entrada[1]
# Probar el perceptrón entrenado
print("Compuerta AND")
for i in range(len(entradas)):
entrada = entradas[i]
salida_deseada = salidas_deseadas[i]
# Calcular la sumatoria y aplicar la función de activación
sumatoria = w1 * entrada[0] + w2 * entrada[1]
salida = activacion(sumatoria)
print(f"Entrada: {entrada} | Salida deseada: {salida_deseada} | Salida: {salida}")
```
{% endcode %}
Al ejecutar este script, obtendrás la salida para cada entrada de la compuerta AND, junto con la salida deseada. Verás cómo el perceptrón se entrena para producir las salidas correctas para todas las entradas de la compuerta lógica AND.
{% hint style="info" %}
En el ejemplo, se estableció un número de iteraciones igual a 10 para limitar la cantidad de veces que se ajustan los pesos del perceptrón. La elección de este valor específico fue arbitraria y puede variar según el problema y la convergencia del algoritmo de entrenamiento.
El propósito de las iteraciones es permitir que el perceptrón realice múltiples ajustes a los pesos con el objetivo de mejorar su capacidad para predecir correctamente la salida deseada. En cada iteración, se presentan los ejemplos de entrenamiento al perceptrón, se calcula la salida y se ajustan los pesos en función del error cometido. Repetir este proceso varias veces permite que el perceptrón se acerque gradualmente a una solución óptima.
En la práctica, el número de iteraciones puede ser determinado experimentalmente, observando el rendimiento del perceptrón en un conjunto de datos de validación o hasta que el error en el entrenamiento se reduzca por debajo de un umbral predefinido.
{% endhint %}
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://red-neuronal-artificial.gitbook.io/neuronas/contenido/1.-introduccion-a-las-redes-neuronales./1.1-arquitectura-de-una-neurona-artificial/perceptron/programando-un-perceptron.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.