Mostrar los tags: neurona

Mostrando del 1 al 7 de 7 coincidencias
<<>>
Se ha buscado por el tag: neurona
Imágen de perfil

Red neuronal CNN, detección de clases.


Python

Publicado el 24 de Marzo del 2024 por Hilario (131 códigos)
377 visualizaciones desde el 24 de Marzo del 2024
CLASES DE IMAGENES CON UNA MUESTRA DE CADA UNA.
-----------------------------------------------------------------------------------
Figure_1
Figure_2
Figure_3
Figure_4
Figure_5

***************************************************************
IMAGEN PROPUESTA A EVALUAR.
------------------------------------------------------------------------------

imagen

****************************************************************************************************************
TUTORIAL DEL EJERCICIO.
--------------------------------------
Este ejercicio que propongo hoy, está realizado con el fin de entender la dinámica, o forma de realizar una red neuronal CNN.

Está compuesto por tres códigos:

1- Aula_28_Descarga_Imagenes.py
-------------------------------
En este primer código accedemos a:
dataset_url = https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz"

De donde descargamos las imagenes necesarias para realizar el posterior modelo.
Las imagenes se guardaran, en nuestro usuario de Linux -Ubuntu-, en un fichero oculto (.Keras),
en un directorio llamado Datasets, en mi caso con la siguiente ruta: /home/margarito/.keras/datasets/flower_photos.
En el directorio:flower_photos, encontraremos las imagenes de las flores, con las clases a que corresponden.

Tres directorios con imágenes de estas clases:

-flower_photos
--daisy
--dandelion
--roses
--sunflowers
--tulips

Con el fin de utilizar estas imagenes de forma indirecta, copiaremos el directorio:-flower_photos
y lo pegaremos en nuestro directorio de usuario.
Al ejecutar este código, se muestra una imagen de cada clase.
---------------------------------------------------
Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:

import matplotlib.pyplot as plt
import numpy as np
import os
import PIL
import tensorflow as tf

from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
import pathlib


*************************************************************************************************************
2-Aula_28_Entreno_Modelo.py
--------------------------
Con este código, lo que hacemos es entrenar el modelo, salvandolo una vez entrenado en nuestro usuario, en el directorio donde tengamos nuestros códigos.

Básicamente este código hace lo siguiente:

Este código en Python utiliza TensorFlow y Keras para construir y entrenar una red
neuronal convolucional (CNN) para clasificar imágenes de flores. Aquí está el desglose de lo que hace cada parte del código:

Importación de bibliotecas:
Importa TensorFlow y algunas clases específicas
de Keras necesarias para el procesamiento de imágenes.

Definición de directorios y ruta del modelo:
Establece las rutas de los directorios donde se encuentran
los datos de entrenamiento de imágenes de flores y donde se guardará el modelo entrenado.

Parámetros de entrenamiento:
Define los parámetros para el entrenamiento,
como el tamaño del lote, la altura y el ancho de las imágenes, y el número de épocas.

Generador de datos de entrenamiento:
Crea un generador de datos de imágenes de entrenamiento
utilizando la clase ImageDataGenerator de Keras.
Esta clase realiza aumento de datos, como escalamiento, recorte, volteo horizontal, etc.

Configuración de generadores de flujo de datos de entrenamiento
y validación:
Configura los generadores de flujo de datos
de entrenamiento y validación utilizando el directorio de datos
de entrenamiento y especificando la división para la validación.

Creación del modelo CNN:
Define el modelo de la CNN utilizando
Sequential de Keras, que es una pila lineal de capas.
El modelo consta de varias capas convolucionales y de agrupación (pooling),
seguidas de capas totalmente conectadas. La última capa utiliza una función
de activación softmax para la clasificación de las clases de flores.

Compilación del modelo:
Compila el modelo especificando el optimizador,
la función de pérdida y las métricas para el entrenamiento.

Entrenamiento del modelo:
Entrena el modelo utilizando los generadores de flujo de datos de entrenamiento y validación.

Guardado del modelo:
Guarda el modelo entrenado en la ruta especificada.

Mensaje de finalización:
Imprime un mensaje para indicar que el modelo ha sido entrenado y guardado correctamente.

Como podéis apreciar, en mi caso de linux, las rutas donde tengo los datos,
y el lugar donde gusrado el modelo, es el siguiente:
# Rutas de los directorios de datos
train_dir = '/home/margarito/python/flower_photos'
model_path = '/home/margarito/python/Mi_Modelo_Hilario.h5'
******************************************************************************************************************

Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
-------------------------------------------------------------------------------------
3-Aula_28_Probar_Modelo.py
-------------------------
Con este código voy a probar el modelo.
En mi caso he sacado una fotografia, a una flor silvestre de diente de leon,
con el fin de evaluar el acierto de mi programa.
Este programa podría resumirse de la siguiente forma:

Este código realiza la inferencia de una imagen de flor utilizando un modelo de red neuronal convolucional (CNN) previamente entrenado. Aquí está el desglose de lo que hace cada parte del código:

Importación de bibliotecas:
Importa las bibliotecas necesarias, incluyendo NumPy para manipulación de matrices
y TensorFlow para el uso del modelo y la preprocesamiento de imágenes.

Cargar el modelo previamente entrenado:
Carga el modelo de CNN previamente entrenado desde la ruta especificada en modelo_ruta.

Ruta de la imagen de la flor:
Define la ruta de la imagen de la flor que se desea clasificar.

Cargar y redimensionar la imagen:
Carga la imagen de la flor desde la ruta especificada
y la redimensiona al tamaño requerido por el modelo, que es 224x224 píxeles.

Convertir la imagen a un array numpy:
Convierte la imagen cargada en un array numpy para que pueda ser procesada por el modelo.

Preprocesamiento de la imagen:
Realiza cualquier preprocesamiento necesario en la imagen, en este caso,
expandiendo las dimensiones del array para que coincida con el formato de entrada esperado por el modelo.

Normalización de los valores de píxeles:
Normaliza los valores de píxeles de la imagen para que estén en el rango de 0 a 1,
lo que es comúnmente necesario para la entrada de los modelos de redes neuronales.

Hacer la predicción:
Utiliza el modelo cargado para realizar la predicción en la imagen preprocesada.

Obtener la clase predicha:
Identifica la clase predicha asignando etiquetas de clases a las salidas del modelo
y seleccionando la clase con el valor de probabilidad más alto.

Imprimir la clase predicha:
Imprime la clase predicha de la flor en la imagen.

En resumen, este código toma una imagen de una flor,
la procesa adecuadamente para que pueda ser ingresada
al modelo, la clasifica utilizando el modelo
previamente entrenado y luego imprime la
clase predicha de la flor en la imagen.
------------------------------------------------------
Librerías necesarias a cargadas en vuestro sistema para la ejecución de este código:

import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing import image

*********************************************************************************
Estos ejercicios han sido realizados y ejecutados bajo consola linux.
Concretamente bajo Ubuntu 20.04.6 LTS.
Fueron editados con Sublime text.

Debereis de tener en cuenta que para la ejecución de los ejercicios
deberéis tener instaladas las librerías y módulos necesarios, segfún se indica en cada código.
----------------------------------------------

SALIDA, EN MI CASO DEL EJERCICIO DE LA IMAGEN PROPUESTA DE EVALUACIÓN:

2024-03-24 12:47:54.765845: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.
2024-03-24 12:47:54.797982: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.
2024-03-24 12:47:54.798348: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
2024-03-24 12:47:55.329900: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT

1/1 [==============================] - ETA: 0s
1/1 [==============================] - 0s 114ms/step
La flor en la imagen es: dandelion
[Finished in 2.9s]
Imágen de perfil

Crear Modelo red neuronal CNN.


Python

Publicado el 14 de Enero del 2024 por Hilario (131 códigos)
336 visualizaciones desde el 14 de Enero del 2024
Con este ejemplo sencillo, pretendo explicar como realizar un ejercicio llamado: Crear_Modelo_CN_Aula-28.py, para entrenar una red neuronal convolucional (CNN), siguiendo varios pasos. Aquí te proporcionaré un resumen general de los pasos que puedes seguir utilizando bibliotecas como TensorFlow y Keras en Python. Ten en cuenta que esto es solo una guía básica, y dependiendo de tus necesidades específicas, es posible que debas ajustar algunos parámetros y configuraciones, incluso incrementar la dificultad del ejercicio.


Paso 1: Preparar tus datos.
--------------------------
Organizar tus datos:

Divide tus datos en conjuntos de entrenamiento y prueba. El conjunto de entrenamiento se utiliza para entrenar el modelo, mientras que el conjunto de prueba se utiliza para evaluar su rendimiento.
Asegúrate de tener etiquetas asociadas a cada imagen para supervisar el entrenamiento.

Preprocesamiento de imágenes:
----------------------------
Normaliza las imágenes (escala los valores de píxeles entre 0 y 1).
Redimensiona las imágenes según los requisitos de entrada de tu red neuronal.

Paso 2: Crear la arquitectura de la CNN.
---------------------------------------
Importar bibliotecas:

Importa TensorFlow y Keras.
Definir el modelo:

Crea un modelo secuencial (Sequential) o funcional de Keras.
-----------------------------------------------------------
Agrega capas convolucionales, capas de agrupación (pooling), y capas totalmente conectadas según tu arquitectura.

Paso 3: Compilar el modelo.
--------------------------
Compilar el modelo:
Especifica la función de pérdida, el optimizador y las métricas que se utilizarán para evaluar el rendimiento del modelo.
Utiliza el método compile de Keras.

Paso 4: Entrenar el modelo.
--------------------------
Entrenar el modelo:
Utiliza el método fit de Keras.
Proporciona el conjunto de entrenamiento y valida con el conjunto de prueba.
Ajusta el número de épocas y el tamaño del lote según sea necesario.

Paso 5: Evaluar el modelo.
-------------------------
Evaluar el modelo:
Utiliza el conjunto de prueba para evaluar el rendimiento del modelo.
Puedes usar el método evaluate de Keras.

Paso 6: Guardar el modelo entrenado.
----------------------------------
Guardar el modelo:
Utiliza la función save de Keras para guardar el modelo entrenado en un archivo.

PRESENTACION DE LAS IMAGENES DE ENTRENAMIENTO.
********************************************

Básicamente estamos hablando de dos formas:

[indent]CASO_1
*****

Imaginate que tengo estas imagenes:
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg

[/indent]
*************************************************************************************
Sí, en tu caso, no hay clases específicas y solo tienes un conjunto de imágenes numeradas, simplemente colocarlas en orden jerárquico dentro del directorio de entrenamiento (train) es suficiente. La estructura que te proporciono como ejemplo refleja esa simplicidad.
Esta podría ser una ruta normal de archivos, al que llamamos en el directorio principal: ProyectoCNN

[indent]ProyectoCNN/
└── dataset/
└── train/
├── imagen_1.jpg
├── imagen_2.jpg
├── imagen_3.jpg
├── imagen_4.jpg
├── imagen_5.jpg
├── imagen_6.jpg
├── imagen_7.jpg
├── imagen_8.jpg
├── ...
└── imagen_124.jpg
[/indent]
----------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------

CASO_2.
*********

En nuestro ejemplo utilizaremos, este formato de almacenamiento (CASO_2.), para entrenar el modelo.

Bien, imaginate ahora que tenemos estos directorios de clase:

(En mi caso, con el fin de coger el concepto de su funcionamiento solo he aportado 3 imagenes para cada tipo. Por lo
que los resultados de la predicción son bastante pobre, para aumentar la eficacia debería hacerse con miles de imagenes. Ten en cuenta que habitualmente para train, los modelos ya entrenados que descargamos pueden rondar las 60.000 imagenes.)

[[indent]b]camiones:
--------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg

turismos:
--------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg

autocares:
----------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg

motocicletas:
------------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg[/b]
[/indent]
Como organizarias las imagenes para entrenar un modelo CNN.
----------------------------------------------------------
En principio, nosotros las organizariamos como sigue. Sin duda
puede haber más opciones que puedes experimentar,siempre que des la ruta adecuada
de acceso a tu modelo:ProyectoCNN.
ProyectoCNN/
└── dataset/
├── train/
│ ├── camiones/
│ │ ├── imagen_1.jpg
│ │ ├── imagen_2.jpg
│ │ ├── ...
│ │ └── imagen_124.jpg
│ ├── turismos/
│ │ ├── imagen_1.jpg
│ │ ├── imagen_2.jpg
│ │ ├── ...
│ │ └── imagen_124.jpg
│ ├── autocares/
│ │ ├── imagen_1.jpg
│ │ ├── imagen_2.jpg
│ │ ├── ...
│ │ └── imagen_124.jpg
│ └── motocicletas/
│ ├── imagen_1.jpg
│ ├── imagen_2.jpg
│ ├── ...
│ └── imagen_124.jpg
├── validation/
│ (mismo formato que 'train')
└── test/
(mismo formato que 'train')


En este ejemplo, he organizado las imágenes en tres conjuntos: entrenamiento (train), validación (validation), y prueba (test). Cada conjunto tiene subdirectorios para cada clase de vehículo (camiones, turismos, autocares, motocicletas). Esto es una práctica común al trabajar con modelos de aprendizaje profundo.

Espero que esto te ayude a estructurar tus datos para el entrenamiento de tu modelo CNN. Asegúrate de ajustar la división entre conjuntos de entrenamiento, validación y prueba según tus necesidades específicas.

**************************************************************************************************************
Los directorios "validation" y "test" son comúnmente utilizados en el entrenamiento de modelos de aprendizaje profundo, como las redes neuronales convolucionales (CNN), para evaluar el rendimiento del modelo en datos que no ha visto durante el entrenamiento. Aquí hay una breve descripción de cada uno:

Conjunto de Validación:
----------------------
Propósito: Se utiliza durante el entrenamiento del modelo para ajustar los hiperparámetros y evitar el sobreajuste (overfitting).

Composición:
---------------
Contiene datos adicionales que no se utilizan para entrenar directamente el modelo, pero se emplean para evaluar su rendimiento durante cada época (epoch) del entrenamiento.

Cómo se usa:
-----------
Después de cada época (epoch), de entrenamiento, el modelo se evalúa en el conjunto de validación. Esto permite ajustar los hiperparámetros del modelo para mejorar su rendimiento en datos que no forman parte del conjunto de entrenamiento.

Conjunto de Prueba (Test):
-------------------------

Propósito:
----------------
Se utiliza al final del entrenamiento para evaluar el rendimiento final del modelo en datos completamente nuevos que no se han visto en absoluto durante el proceso de entrenamiento.

Composición:
-----------
Contiene datos independientes que el modelo nunca ha visto ni durante el entrenamiento ni durante la validación.

Cómo se usa:
-----------
Una vez que el modelo ha sido entrenado y ajustado utilizando el conjunto de entrenamiento y de validación, se evalúa de manera final en el conjunto de prueba para obtener una estimación imparcial de su rendimiento en datos no vistos.
La separación entre conjuntos de entrenamiento, validación y prueba ayuda a garantizar que el modelo sea capaz de generalizar bien a datos no vistos y no se sobreajuste a los datos de entrenamiento específicos.

En resumen, el conjunto de validación es utilizado para ajustar los hiperparámetros y evitar el sobreajuste durante el entrenamiento, mientras que el conjunto de prueba proporciona una evaluación final del rendimiento del modelo en datos completamente nuevos y no vistos.
********************************************************************************************************************

Debes asegurarte, para no generar errores, que las rutas, en tu caso, sean exactas.
El ejercicio para generar el módelo tendría este código, que también te pongo en el editor de códigos:
----------------------------------------------------------------------------------
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Rutas de los datos de entrenamiento, validación y prueba
train_data_dir = 'ProyectoCNN/dataset/train'
validation_data_dir = 'ProyectoCNN/dataset/validation'
test_data_dir = 'ProyectoCNN/dataset/test'

# Parámetros
batch_size = 32
img_height = 64
img_width = 64

# Crear generadores de datos para entrenamiento, validación y prueba
train_datagen = ImageDataGenerator(rescale=1./255)
validation_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(
train_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical') # 'categorical' ya que hay más de dos clases

validation_generator = validation_datagen.flow_from_directory(
validation_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical')

test_generator = test_datagen.flow_from_directory(
test_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical')

# Construir el modelo CNN
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(img_height, img_width, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(4, activation='softmax')) # 'softmax' ya que hay más de dos clases

# Compilar el modelo
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])

# Entrenar el modelo
model.fit(train_generator, epochs=10, validation_data=validation_generator)

# Evaluar el modelo en el conjunto de prueba
test_loss, test_acc = model.evaluate(test_generator)
print(f'Precisión en el conjunto de prueba: {test_acc}')

# Guardar el modelo
model.save('modelo_cnn_proyecto.h5')

**********************************************************************************************************
**************************************************************************************************************
Bien. En mi caso. Una vez creado el modelo con esta ruta: /home/margarito/python/modelo_cnn_proyecto.h5.
Necesito entrenar una red neuronal CNN, con el modelo: modelo_cnn_proyecto.h5 Que dada la ruta de esta
imagen de un turismo en esta ruta:/home/margarito/python/coche.jpeg . Me diga si es un camion,
una motocicleta, un coche, o un autocar.ñ

-----------------------------------------------------------------------------------------------------------
Después de haber entrenado tu modelo, puedes usarlo para hacer predicciones sobre nuevas imágenes.
Aquí tienes un ejemplo de cómo cargar el modelo y realizar una predicción sobre la imagen de un turismo:

import tensorflow as tf
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import preprocess_input, decode_predictions
import numpy as np

# Cargar el modelo previamente entrenado
modelo = tf.keras.models.load_model('/home/margarito/python/modelo_cnn_proyecto.h5')

# Cargar la imagen de un coche
img_path = '/home/margarito/python/coche.jpeg'
img = image.load_img(img_path, target_size=(64, 64))
img_array = image.img_to_array(img)
img_array = np.expand_dims(img_array, axis=0)
img_array = preprocess_input(img_array)

# Realizar la predicción
predictions = modelo.predict(img_array)

# Obtener las clases predichas
class_indices = {0: 'camiones', 1: 'turismos', 2: 'autocares', 3: 'motocicletas'}
predicted_class = class_indices[np.argmax(predictions)]

# Imprimir el resultado
print(f'Predicción: {predicted_class}')


------------------------------------------------------------------------------------------
Este script carga la imagen del coche, la preprocesa de manera adecuada para el modelo, realiza la predicción y luego imprime la clase predicha. Asegúrate de que la imagen esté en el formato adecuado y ajusta las rutas según sea necesario. Recuerda que el modelo fue entrenado con clases específicas ('camiones', 'turismos', 'autocares', 'motocicletas'), así que las clases predichas deben coincidir con estas categorías.

************************************************************************************
[b]El ejercicio fue realizado bajo plataforma Linux.
Concretamente:Ubuntu 20.04.6 LTS
Editado con:Sublime Text.
-------------------------
Se debe de tener en cuenta que en tu ordenador deberan estar cargadas las librerias necesarias.
En nuestro caso:
---------------
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
-------------------------------------------
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import preprocess_input, decode_predictions
import numpy as np
************************************************************************************
Ejecucion de los programas:

#Crear_Modelo_CN_Aula-28.py
#Ejecución:python3 Crear_Modelo_CN_Aula-28.py
--------------------------------------------------
#Util_Modelo_Creado_Aula-28.py
#Ejecutar: python3 Util_Modelo_Creado_Aula-28.py
*******************************************************************************************************
Imágen de perfil

Perseptron simple


Visual Basic.NET

estrellaestrellaestrellaestrellaestrella(1)
Publicado el 26 de Abril del 2021 por Rafael Angel (81 códigos)
2.941 visualizaciones desde el 26 de Abril del 2021
Mi primer neur
Neurona-artificial-modificada-por-Rafael-Angel-Montero-Fernandezona Perseptron, si bien desde el 2012 ya sabia hacer neuronas artificiales, yo estaba consciente que le faltaba algunas cosas.
No estaba 100% seguro de los conceptos.
En aquellos días era difícil ver tutoriales por video; hoy día es diferente, rápidamente se puede aprender viendo un video.
Nada como la comunicación verbal en combinación con el lenguaje corporal de un ser humano.
.
Dicha neurona es capaz de aprender, tiene todos los objetos que tiene una neurona, más un extra, la función de nacionalización de los pesos, con lo cual no es necesario usar un valor aleatorio.
Imágen de perfil

neurona artificial 1 0 -1, trinaria


Java

Publicado el 24 de Septiembre del 2017 por Rafael Angel (81 códigos)
1.943 visualizaciones desde el 24 de Septiembre del 2017
Neurona artificial con tres salidas diferentes.
Le he hecho una actualización a la neurona artificial normal; la actualización incluye la habilidad de ser trinaria y no binaria. O sea tiene el poder de lanzar: 1, 0, -1.
Ademas no pierde la habilidad de aprender.
Recuerden nosotros como humanos no somos binarios, somos trinarios o más todavía, nosotros usamos, si, no, talvez. Ya es hora que la computación tenga ese talvez, eso que nos hace humanos.
Imágen de perfil

Neurona artificial capaz de aprender


Java

estrellaestrellaestrellaestrellaestrella(7)
Publicado el 22 de Julio del 2017 por Rafael Angel (81 códigos)
24.067 visualizaciones desde el 22 de Julio del 2017
Una simple neurona artificial para desarrollar habilidades en este paradigma relacionado con la programación en paralelo.

Si sabes programar nodos, si sabes de redes entonces puedes crear o simular una red neuronal con esta neurona.
Imágen de perfil

Detección de imágenes mediante el uso de Visión Artificial


Matlab

estrellaestrellaestrellaestrellaestrella(14)
Actualizado el 22 de Octubre del 2015 por Jesus (Publicado el 12 de Noviembre del 2014)
21.768 visualizaciones desde el 12 de Noviembre del 2014
El siguiente código detecta imágenes tomadas con la cámara WEB y las compara con 2 imágenes que se le enseñan a una Red Neuronal Artificial y obtiene una salida que nos dice a que imagen se parece.

Interfaz

La estructura que implementamos fue la siguiente:

Prototipo

Se utiliza un algoritmo conocido como Regla de Hebb.

Desarrollado por:
Castañeda espinosa Jesus
Cesar Zetina Gaspar Antonio
Pedro Mendoza Erick Eduardo
Facultad de Ingeniería UNAM