Código de Python - Transfer Learning.

Imágen de perfil

Transfer Learning.gráfica de visualizaciones


Python

Publicado el 28 de Diciembre del 2023 por Hilario (123 códigos)
299 visualizaciones desde el 28 de Diciembre del 2023
seis
numeropredicho
**********************************************************************************************************

Propongo este sencillo ejercicio llamado:AULA-288_Transf_Apren_CNN.py, si utilizamos nuestro propio editor, Sublime text, y ejecutamos directamente en nuestra consola linux. O también llamado:AULA-288_Transf_Apren_CNN.ipynb, si utlizamos para editar y ejecutar a Google Colab.

En ambos casos, utilizamos indirectamente el método denominado "Transferencia de aprendizaje", con el fin de apreciar cual es el proceso de este sistema de red Convolucional(CNN).

Se trata, utilizando Machine Learning de la mano de TensorFlow y Keras, dos librerías Open Source que nos permiten adentrarnos en el Deep Learning de forma sencilla. De entre las muchas bibliotecas disponibles una de las más importantes es indiscutiblemente es TensorFlow, que se ha impuesto como la librería más popular en Deep Learning. Actualmente, sería difícil imaginar abordar un proyecto de aprendizaje sin ella.

Básicamente, para entenderlo, es una biblioteca de código abierto para realizar operaciones matemáticas de manera eficiente, especialmente diseñada para trabajar con redes neuronales y aprendizaje profundo (deep learning).


Keras, por otro lado, es una interfaz de alto nivel para construir y entrenar modelos de aprendizaje profundo. Facilita la construcción y experimentación con redes neuronales de una manera más simple y amigable.

TensorFlow.keras:
TensorFlow.keras es una implementación de la interfaz de Keras que está integrada directamente en TensorFlow. Esto significa que puedes usar las funciones y herramientas de TensorFlow mientras trabajas con la sencillez y flexibilidad de Keras.

En resumen, TensorFlow.keras es una combinación que aprovecha la potencia de TensorFlow para realizar cálculos eficientes en el fondo, mientras que proporciona una interfaz amigable y fácil de usar para diseñar y entrenar modelos de aprendizaje profundo mediante la simplicidad de Keras. Esto facilita el desarrollo de aplicaciones de inteligencia artificial y aprendizaje profundo de una manera más accesible para los desarrolladores.

En este ejercicio, primero entrenamos el modelo, creando el mismo, alojandolo en el fichero: mnist_model.h5. En un caso, dependiendo el método de ejecución será guardado en Drive, o en nuestro propio ordenador. Luego cargaremos la imagen del número propuesto, que hemos fotografiado con el móvil, una vez dibujado a mano en color negro, sobre fondo blanco.

AQUÍ RESUMIMOS LOS PASOS NECESARIOS.
----------------------------------
Dibujar el número:
Preparar el papel o la superficie: Asegúrate de tener un fondo claro y limpio para que el número se destaque.

Dibuja el número: Utiliza un lápiz o bolígrafo para dibujar claramente el número en el papel. Trata de mantener el trazo claro y definido.

Contraste: Asegúrate de que haya suficiente contraste entre el número y el fondo para que el modelo pueda distinguirlo fácilmente.

Fotografiar el número:
Buena iluminación: Coloca la hoja con el número en un lugar bien iluminado. La iluminación uniforme puede ayudar a obtener una imagen de mejor calidad.

Ángulo y enfoque: Fotografía el número desde arriba para evitar distorsiones. Asegúrate de que la imagen esté enfocada y que el número sea claramente visible.

Fondo simple: Trata de tener un fondo simple y sin distracciones para que el modelo se centre en el número.

Preprocesamiento de la imagen:
Recortar y redimensionar: Recorta la imagen para que solo contenga el número y redimensiona la imagen según sea necesario.

Convertir a escala de grises: Convierte la imagen a escala de grises si es un número en blanco y negro, o a escala de colores si es en color.

Utilizar el número en un modelo de CNN:
Preparar los datos: Dependiendo del modelo y la biblioteca que estés utilizando (por ejemplo, TensorFlow y Keras), es posible que necesites ajustar el formato de la imagen o realizar otras transformaciones.

Entrenar el modelo: Entrena tu modelo de CNN utilizando el conjunto de datos que has creado con las imágenes de los números.

Prueba el modelo: Utiliza nuevas imágenes para probar la capacidad de tu modelo para reconocer los números.

Recuerda que la calidad de las imágenes y la cantidad de datos de entrenamiento son factores críticos para el éxito de tu modelo de CNN. Cuanto más variados y representativos sean los datos de entrenamiento, mejor será la capacidad del modelo para generalizar y reconocer números en situaciones diversas.

COMO EJECUTAR EL EJERCICIO.
---------------------------
Como hemos comentado al inicio, podemos utilizar dos métodos.

1-GOOGLE COLAB.
--------------
En este caso tendremos una cuenta abierta en Google Colab, y en Drive, con el fin de ejecutar online el ejercicio. Montando debidamente Drive.
Deberemos especificar correctamente las rutas tando de la carga de la imagen del número a predecir, como la descarga y alojamiento del fichero.
2-BAJO CONSOLA LINUX.
-------------------
En mi caso el ejercicio se utiliza Ubuntu 20.04.6 LTS, y el editor Sublime Text.

En este caso, también deberemos especificar correctamente las rutas tando de la carga de la imagen del número a predecir, como la descarga y alojamiento del fichero.
*************************************************************

Con el fin de que no haya conflictos con CUDA, hemos colocado esta linea de código en ambos ejercicios:
Para utilizar la CPU de tu ordenador, aunque en el caso de Google Colab, utilizamos su sistema online.

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # Establece la variable de entorno para usar la CPU de tu ordenador, al no tener, en muchos casos una tarjeta NVIDEA.

---------------------------------------------------------
QUE ES CUDA:

CUDA es una plataforma de cómputo paralelo desarrollada por NVIDIA que permite utilizar la potencia de procesamiento de las unidades de procesamiento gráfico (GPU) para realizar cálculos de propósito general. La sigla CUDA proviene de "Compute Unified Device Architecture" (Arquitectura de Dispositivo Unificado para Cómputo, en español).

A continuación, te proporciono algunos puntos clave sobre CUDA:

Programación en paralelo: CUDA proporciona un entorno de programación en paralelo que permite a los desarrolladores aprovechar la capacidad de procesamiento masivo de las GPUs para realizar cálculos intensivos. Esto es especialmente útil para aplicaciones que pueden dividirse en tareas independientes que se pueden ejecutar simultáneamente.

Modelo de programación: CUDA utiliza un modelo de programación basado en el lenguaje de programación C, lo que facilita a los desarrolladores escribir código para ejecutar en las GPUs de NVIDIA.

Núcleos de procesamiento: Las GPUs de NVIDIA están compuestas por un gran número de núcleos de procesamiento, que pueden ejecutar tareas de forma paralela. CUDA permite a los desarrolladores escribir programas que distribuyen estas tareas en los núcleos de manera eficiente.

Aplicaciones comunes: CUDA se utiliza comúnmente en aplicaciones de alto rendimiento, como el procesamiento de imágenes y videos, simulaciones científicas, aprendizaje profundo (deep learning), criptografía y otros campos que requieren un procesamiento intensivo.

Bibliotecas y herramientas: NVIDIA proporciona bibliotecas y herramientas específicas de CUDA, como cuBLAS (para álgebra lineal básica), cuDNN (para redes neuronales profundas), y otras, que facilitan el desarrollo de aplicaciones de alto rendimiento.

Desarrollo de software: Para utilizar CUDA, los desarrolladores suelen escribir código en lenguaje CUDA C y utilizan herramientas proporcionadas por NVIDIA, como el compilador NVCC (NVIDIA CUDA Compiler).

En resumen, CUDA es una tecnología que permite aprovechar la potencia de las GPUs de NVIDIA para realizar cálculos paralelos, lo que resulta especialmente valioso en aplicaciones que requieren un alto rendimiento computacional.

Requerimientos

Cuando, lo ejecutemos bajo consola Linux, es muy importante tener cargadas en nuestro ordenador
todas las importaciones de módulos.

EN NUESTRO CASO.
----------------------------
import os
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
import matplotlib.pyplot as plt
from PIL import Image

---------------------------------------------------------------------------
Ejecución del ejercicio bajo CONSOLA LINUX.

python3 AULA-288_Transf_Apren_CNN.py

V-0.

Publicado el 28 de Diciembre del 2023gráfica de visualizaciones de la versión: V-0.
300 visualizaciones desde el 28 de Diciembre del 2023
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
**************************************************************************************************************
             EJERCICIO EJECUTADO BAJO GOOGLE COLAB.
*******************************************************************************************************************
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '-1'  # Establece la variable de entorno para usar la CPU de tu ordenador
 
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
import matplotlib.pyplot as plt
from PIL import Image
 
# Ajusta el número de hilos (Esto es si quieres es opcional)
tf.config.threading.set_inter_op_parallelism_threads(2)
tf.config.threading.set_intra_op_parallelism_threads(2)
 
# Cargar y preprocesar el conjunto de datos MNIST
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255
 
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)
 
# Construir el modelo de la red neuronal convolucional (CNN)
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
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(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
 
# Compilar el modelo
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
 
# Entrenar el modelo
model.fit(train_images, train_labels, epochs=5, batch_size=64, validation_split=0.2)
 
# Guardar el modelo entrenado
model.save('/content/drive/MyDrive/mnist_model.h5')  # Cambia la ruta según tu preferencia
 
# Cargar el modelo
mnist_model = tf.keras.models.load_model('/content/drive/MyDrive/mnist_model.h5')  # Cambia la ruta según tu preferencia
 
# Convertir la función predict_image en una función de TensorFlow
@tf.function
def predict_image(img_array):
    return mnist_model(img_array)
 
# Realizar predicciones en una imagen específica
img_path = '/content/drive/MyDrive/druida/cinco.png'
 
# Verificar la existencia del archivo
if not os.path.exists(img_path):
    print(f"El archivo no existe en la ruta especificada: {img_path}")
else:
    # Abrir la imagen original
    img_original = Image.open(img_path)
 
    # Especificar el nuevo tamaño (por ejemplo, 28x28 píxeles)
    new_size = (28, 28)
 
    # Redimensionar y convertir la imagen a escala de grises
    img_resized = img_original.resize(new_size).convert('L')
 
    # Convertir la imagen redimensionada a un array
    img_array = tf.keras.preprocessing.image.img_to_array(img_resized)
    img_array = tf.expand_dims(img_array, 0)
    img_array = img_array / 255.0
 
    # Hacer la predicción
    predictions = predict_image(img_array)
 
    # Obtener el número predicho
    predicted_number = tf.argmax(predictions[0]).numpy()
 
    # Mostrar la predicción junto con la imagen
    plt.imshow(img_resized, cmap='gray')
    plt.title(f'Número predicho: {predicted_number}')
    plt.show()
 
*************************************************************************************************************
                                  EJECUTAR BAJO CONSOLA LINUX, EDITOR SUBLIME TEXT.
 
******************************************************************************************************************
 
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '-1'  # Establece la variable de entorno para usar la CPU de tu ordenador
 
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
import matplotlib.pyplot as plt
from PIL import Image
 
# Ajusta el número de hilos (Esto es si quieres es opcional)
tf.config.threading.set_inter_op_parallelism_threads(2)
tf.config.threading.set_intra_op_parallelism_threads(2)
 
# Cargar y preprocesar el conjunto de datos MNIST
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255
 
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)
 
# Construir el modelo de la red neuronal convolucional (CNN)
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
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(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
 
# Compilar el modelo
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
 
# Entrenar el modelo
model.fit(train_images, train_labels, epochs=5, batch_size=64, validation_split=0.2)
 
# Guardar el modelo entrenado
model.save('/home/python/python/mnist_model.h5')  # Cambia la ruta según tu preferencia
 
# Cargar el modelo
mnist_model = tf.keras.models.load_model('/home/margarito/python/mnist_model.h5')  # Cambia la ruta según tu preferencia
 
# Convertir la función predict_image en una función de TensorFlow
@tf.function
def predict_image(img_array):
    return mnist_model(img_array)
 
# Realizar predicciones en una imagen específica
img_path = '/home/python/python/seis.jpeg'
 
# Verificar la existencia del archivo
if not os.path.exists(img_path):
    print(f"El archivo no existe en la ruta especificada: {img_path}")
else:
    # Abrir la imagen original
    img_original = Image.open(img_path)
 
    # Especificar el nuevo tamaño (por ejemplo, 28x28 píxeles)
    new_size = (28, 28)
 
    # Redimensionar y convertir la imagen a escala de grises
    img_resized = img_original.resize(new_size).convert('L')
 
    # Convertir la imagen redimensionada a un array
    img_array = tf.keras.preprocessing.image.img_to_array(img_resized)
    img_array = tf.expand_dims(img_array, 0)
    img_array = img_array / 255.0
 
    # Hacer la predicción
    predictions = predict_image(img_array)
 
    # Obtener el número predicho
    predicted_number = tf.argmax(predictions[0]).numpy()
 
    # Mostrar la predicción junto con la imagen
    plt.imshow(img_resized, cmap='gray')
    plt.title(f'Número predicho: {predicted_number}')
    plt.show()



Comentarios sobre la versión: V-0. (0)


No hay comentarios
 

Comentar la versión: V-0.

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s7476