import tensorflow as tf
from [Link] import Sequential, Model
from [Link] import ImageDataGenerator
from [Link] import BatchNormalization, Conv2D, MaxPooling2D,
Dense, Flatten, Activation, Dropout, GlobalAveragePooling2D
from [Link] import normalize, to_categorical
from [Link] import VGG16
from [Link] import RMSprop
from [Link] import backend as K
from [Link] import EarlyStopping, ModelCheckpoint
import numpy as np
import [Link] as plt
from [Link] import image
import os
import random
from PIL import ImageFile
from scipy import ndimage
import cv2
ImageFile.LOAD_TRUNCATED_IMAGES = True
# Tamaño de la imagen
img_width, img_height = 224, 224 # Cambiado a 224x224 para ser compatible con
VGG16
# Montar Google Drive
from [Link] import drive
[Link]("/content/drive", force_remount=True)
train_data_dir = r'/content/drive/MyDrive/Colab Notebooks/dataset-NARAJANAS/train'
validation_data_dir = r'/content/drive/MyDrive/Colab
Notebooks/dataset-NARAJANAS/test'
nb_train_samples = 1490
nb_validation_samples = 608
batch_size = 30
epochs = 20 # Aumentado para permitir más entrenamiento
# Código para definir el input_shape
if K.image_data_format() == "channels_first":
input_shape = (3, img_width, img_height)
else:
input_shape = (img_width, img_height, 3)
# Función para aplicar el filtro de la mediana
def apply_median_filter(img_array, size=3):
"""
Aplica un filtro de la mediana a la imagen.
:param img_array: Array de la imagen (height, width, channels)
:param size: Tamaño de la ventana del filtro (debe ser impar)
:return: Imagen con el filtro aplicado
"""
return ndimage.median_filter(img_array, size=(size, size, 1))
# Clase personalizada de ImageDataGenerator con filtro de la mediana
class MedianFilterImageDataGenerator(ImageDataGenerator):
def flow_from_directory(self, *args, **kwargs):
generator = super().flow_from_directory(*args, **kwargs)
while True:
x, y = next(generator)
x = [Link]([apply_median_filter(img) for img in x])
yield x, y
# Preprocesamiento de imágenes
train_datagen = MedianFilterImageDataGenerator(
rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory(
train_data_dir,
target_size=(img_width, img_height),
batch_size=batch_size,
class_mode='categorical') # Cambiado a 'categorical' para softmax
validation_generator = test_datagen.flow_from_directory(
validation_data_dir,
target_size=(img_width, img_height),
batch_size=batch_size,
class_mode='categorical') # Cambiado a 'categorical' para softmax
# Visualización del preprocesamiento
def plot_images(generator, num_images=9):
# Obtener imágenes originales
original_generator = ImageDataGenerator(rescale=1./255).flow_from_directory(
train_data_dir,
target_size=(img_width, img_height),
batch_size=num_images,
class_mode='categorical',
shuffle=True
)
original_batch, labels = next(original_generator)
# Obtener imágenes procesadas
processed_batch, _ = next(generator)
# Crear la figura
fig, axes = [Link](num_images, 2, figsize=(10, 4*num_images))
for i in range(num_images):
# Mostrar imagen original
axes[i, 0].imshow(original_batch[i])
axes[i, 0].axis('off')
axes[i, 0].set_title('Original')
# Mostrar imagen procesada
axes[i, 1].imshow(processed_batch[i])
axes[i, 1].axis('off')
axes[i, 1].set_title('Procesada')
plt.tight_layout()
[Link]()
print("Imágenes del conjunto de entrenamiento antes y después del preprocesamiento
completo:")
plot_images(train_generator)
import numpy as np
import random
from PIL import Image, ImageEnhance, ImageFilter
import [Link] as plt
# Función para calcular la luminosidad de una imagen
def calcular_luminosidad(image):
grayscale_image = [Link]('L') # Convertir a escala de grises
histogram = grayscale_image.histogram()
pixels = sum(histogram)
luminosidad = sum(i * histogram[i] for i in range(256)) / pixels
return luminosidad
# Función para calcular la nitidez de una imagen
def calcular_nitidez(image):
edge_image = [Link](ImageFilter.FIND_EDGES) # Aplicar un filtro de
detección de bordes
histogram = edge_image.histogram()
nitidez = sum(histogram)
return nitidez
# Función para desnormalizar imágenes (valores de 0-1 a 0-255)
def desnormalizar_imagen(image_array):
return (image_array * 255).astype('uint8')
# Seleccionar aleatoriamente 5 imágenes del generador de datos procesados
def analizar_imagenes_procesadas(generator, num_images=5):
# Obtener imágenes procesadas
processed_batch, _ = next(generator)
indices = [Link](range(processed_batch.shape[0]), num_images) #
Seleccionar aleatoriamente 5 imágenes
fig, axes = [Link](num_images, 1, figsize=(10, 4*num_images))
for i, idx in enumerate(indices):
img_array = processed_batch[idx]
# Desnormalizar la imagen
img_array = desnormalizar_imagen(img_array)
# Convertir el array a imagen
img = [Link](img_array)
# Mostrar imagen
axes[i].imshow(img)
axes[i].axis('off')
axes[i].set_title(f'Imagen {i+1}')
# Calcular tamaño
size = [Link]
# Calcular luminosidad
luminosidad = calcular_luminosidad(img)
# Calcular nitidez
nitidez = calcular_nitidez(img)
print(f"Imagen {i+1}:")
print(f"Tamaño: {size}")
print(f"Luminosidad: {luminosidad:.2f}")
print(f"Nitidez: {nitidez:.2f}")
print("------------")
plt.tight_layout()
[Link]()
# Llamar a la función para analizar 5 imágenes procesadas
analizar_imagenes_procesadas(train_generator)
import numpy as np
import random
from PIL import Image, ImageEnhance, ImageFilter
import [Link] as plt
from [Link] import ImageDataGenerator
# Función para calcular la luminosidad de una imagen
def calcular_luminosidad(image):
grayscale_image = [Link]('L') # Convertir a escala de grises
histogram = grayscale_image.histogram()
pixels = sum(histogram)
luminosidad = sum(i * histogram[i] for i in range(256)) / pixels
return luminosidad
# Función para calcular la nitidez de una imagen
def calcular_nitidez(image):
edge_image = [Link](ImageFilter.FIND_EDGES) # Aplicar un filtro de
detección de bordes
histogram = edge_image.histogram()
nitidez = sum(histogram)
return nitidez
# Función para desnormalizar imágenes (valores de 0-1 a 0-255)
def desnormalizar_imagen(image_array):
return (image_array * 255).astype('uint8')
# Función para redimensionar imágenes a 224x224
def redimensionar_imagen(image, tamaño=(224, 224)):
return [Link](tamaño, [Link])
# Función para procesar imágenes (puedes aplicar aquí cualquier procesamiento
necesario)
def procesar_imagen(image):
# Ejemplo de procesamiento: mejorar el contraste
enhancer = [Link](image)
processed_image = [Link](1.5) # Aumentar el contraste
return processed_image
# Función para comparar las imágenes originales y procesadas
def comparar_imagenes(original_generator, num_images=5):
# Obtener las imágenes originales
original_batch, _ = next(original_generator)
# Asegurarse de que el número de imágenes no exceda el tamaño del lote
num_images = min(num_images, original_batch.shape[0])
# Seleccionar aleatoriamente 'num_images' imágenes
indices = [Link](range(num_images), num_images)
fig, axes = [Link](num_images, 2, figsize=(12, 4*num_images))
for i, idx in enumerate(indices):
# Imagen original
original_img_array = original_batch[idx]
original_img = [Link](desnormalizar_imagen(original_img_array))
original_img = redimensionar_imagen(original_img) # Redimensionar imagen
original a 224x224
# Imagen procesada
processed_img = procesar_imagen(original_img) # Procesar la imagen
original
# Comparar luminosidad
original_luminosidad = calcular_luminosidad(original_img)
processed_luminosidad = calcular_luminosidad(processed_img)
# Comparar nitidez
original_nitidez = calcular_nitidez(original_img)
processed_nitidez = calcular_nitidez(processed_img)
# Mostrar imágenes lado a lado
axes[i, 0].imshow(original_img)
axes[i, 0].axis('off')
axes[i, 0].set_title(f'Original - {i+1}')
axes[i, 1].imshow(processed_img)
axes[i, 1].axis('off')
axes[i, 1].set_title(f'Procesada - {i+1}')
# Imprimir las comparaciones
print(f"Comparación de la imagen {i+1}:")
print(f"Luminosidad Original: {original_luminosidad:.2f}, Luminosidad
Procesada: {processed_luminosidad:.2f}")
print(f"Nitidez Original: {original_nitidez:.2f}, Nitidez Procesada:
{processed_nitidez:.2f}")
print("------------")
plt.tight_layout()
[Link]()
# Definir la ruta a tus imágenes originales
train_data_dir = '/content/drive/MyDrive/Colab Notebooks/dataset-NARAJANAS/train'
# Actualiza esta ruta
# Generar un generador para las imágenes originales (sin procesamiento)
original_generator = ImageDataGenerator(rescale=1./255).flow_from_directory(
train_data_dir,
target_size=(224, 224), # Redimensionar a 224x224
batch_size=5,
class_mode='categorical',
shuffle=True
)
# Llamar a la función para comparar imágenes originales y procesadas
comparar_imagenes(original_generator)
import numpy as np
import random
from PIL import Image, ImageEnhance, ImageFilter
import [Link] as plt
from [Link] import ImageDataGenerator
# Función para calcular la luminosidad de una imagen
def calcular_luminosidad(image):
grayscale_image = [Link]('L') # Convertir a escala de grises
histogram = grayscale_image.histogram()
pixels = sum(histogram)
luminosidad = sum(i * histogram[i] for i in range(256)) / pixels
return luminosidad
# Función para calcular la nitidez de una imagen
def calcular_nitidez(image):
edge_image = [Link](ImageFilter.FIND_EDGES) # Aplicar un filtro de
detección de bordes
histogram = edge_image.histogram()
nitidez = sum(histogram)
return nitidez
# Función para desnormalizar imágenes (valores de 0-1 a 0-255)
def desnormalizar_imagen(image_array):
return (image_array * 255).astype('uint8')
# Función para redimensionar imágenes a 224x224
def redimensionar_imagen(image, tamaño=(224, 224)):
return [Link](tamaño, [Link])
# Función para procesar imágenes (puedes aplicar aquí cualquier procesamiento
necesario)
def procesar_imagen(image):
# Ejemplo de procesamiento: mejorar el contraste
enhancer = [Link](image)
processed_image = [Link](1.5) # Aumentar el contraste
return processed_image
# Función para comparar las imágenes originales y procesadas
def comparar_imagenes(original_generator, num_images=5):
# Obtener las imágenes originales
original_batch, _ = next(original_generator)
# Asegurarse de que el número de imágenes no exceda el tamaño del lote
num_images = min(num_images, original_batch.shape[0])
# Seleccionar aleatoriamente 'num_images' imágenes
indices = [Link](range(num_images), num_images)
fig, axes = [Link](num_images, 3, figsize=(18, 4*num_images)) # Añadir
columna para tamaños
for i, idx in enumerate(indices):
# Imagen original
original_img_array = original_batch[idx]
original_img = [Link](desnormalizar_imagen(original_img_array))
original_img_resized = redimensionar_imagen(original_img) # Redimensionar
imagen original a 224x224
# Imagen procesada
processed_img = procesar_imagen(original_img_resized) # Procesar la imagen
original redimensionada
# Obtener tamaños
original_size = original_img_resized.size
processed_size = processed_img.size
# Comparar luminosidad
original_luminosidad = calcular_luminosidad(original_img_resized)
processed_luminosidad = calcular_luminosidad(processed_img)
# Comparar nitidez
original_nitidez = calcular_nitidez(original_img_resized)
processed_nitidez = calcular_nitidez(processed_img)
# Mostrar imágenes lado a lado
axes[i, 0].imshow(original_img_resized)
axes[i, 0].axis('off')
axes[i, 0].set_title(f'Original - {i+1}')
axes[i, 1].imshow(processed_img)
axes[i, 1].axis('off')
axes[i, 1].set_title(f'Procesada - {i+1}')
# Mostrar tamaños
axes[i, 2].text(0.5, 0.5, f'Tamaño Original: {original_size}\nTamaño
Procesada: {processed_size}',
horizontalalignment='center', verticalalignment='center',
fontsize=12)
axes[i, 2].axis('off')
# Imprimir las comparaciones
print(f"Comparación de la imagen {i+1}:")
print(f"Tamaño Original: {original_size}, Tamaño Procesada:
{processed_size}")
print(f"Luminosidad Original: {original_luminosidad:.2f}, Luminosidad
Procesada: {processed_luminosidad:.2f}")
print(f"Nitidez Original: {original_nitidez:.2f}, Nitidez Procesada:
{processed_nitidez:.2f}")
print("------------")
plt.tight_layout()
[Link]()
# Definir la ruta a tus imágenes originales
train_data_dir = '/content/drive/MyDrive/Colab Notebooks/dataset-NARAJANAS/train'
# Actualiza esta ruta
# Generar un generador para las imágenes originales (sin procesamiento)
original_generator = ImageDataGenerator(rescale=1./255).flow_from_directory(
train_data_dir,
target_size=(224, 224), # Redimensionar a 224x224
batch_size=5,
class_mode='categorical',
shuffle=True
)
# Llamar a la función para comparar imágenes originales y procesadas
comparar_imagenes(original_generator)
import [Link] as plt
import numpy as np
# Datos
imagenes = ['Imagen 1', 'Imagen 2', 'Imagen 3', 'Imagen 4', 'Imagen 5']
luminosidad_original = [121.68, 207.66, 138.03, 114.97, 33.31]
luminosidad_procesada = [123.19, 199.18, 135.82, 116.88, 35.08]
nitidez_original = [150528.00, 150528.00, 150528.00, 150528.00, 150528.00]
nitidez_procesada = [150528.00, 150528.00, 150528.00, 150528.00, 150528.00]
x = [Link](len(imagenes)) # La ubicación de las barras
# Crear subgráficas
fig, ax = [Link](2, 1, figsize=(10, 10), sharex=True)
# Graficar luminosidad
ax[0].bar(x - 0.2, luminosidad_original, 0.4, label='Luminosidad Original',
color='blue')
ax[0].bar(x + 0.2, luminosidad_procesada, 0.4, label='Luminosidad Procesada',
color='orange')
ax[0].set_ylabel('Luminosidad')
ax[0].set_title('Comparación de Luminosidad')
ax[0].set_xticks(x)
ax[0].set_xticklabels(imagenes)
ax[0].legend()
# Graficar nitidez
ax[1].bar(x - 0.2, nitidez_original, 0.4, label='Nitidez Original', color='blue')
ax[1].bar(x + 0.2, nitidez_procesada, 0.4, label='Nitidez Procesada',
color='orange')
ax[1].set_ylabel('Nitidez')
ax[1].set_title('Comparación de Nitidez')
ax[1].set_xticks(x)
ax[1].set_xticklabels(imagenes)
ax[1].legend()
# Ajustar diseño
plt.tight_layout()
[Link]()
# Cargar el modelo VGG16 preentrenado y eliminar las capas superiores
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224,
3))
# Congelar las capas convolucionales del modelo base
for layer in base_model.layers:
[Link] = False
# Descongtimas capas del modelo base
#for layer in base_model.layers[-4:]: # Descoelar las úlngela las últimas 4 capas,
por ejemplo
# [Link] = True
# Crear un modelo secuencial
model = Sequential([
base_model,
GlobalAveragePooling2D(),
Dense(64, activation='relu'),
Dense(2, activation='softmax') # Cambiado a 2 neuronas para softmax
])
# Compilar el modelo
[Link](optimizer='adam', loss='categorical_crossentropy',
metrics=['accuracy'])
model_path='best_model.keras'
# Configurar EarlyStopping y ModelCheckpoint
early_stopping = EarlyStopping(monitor='val_loss', patience=10,
restore_best_weights=True)
model_checkpoint = ModelCheckpoint(model_path, monitor='val_loss',
save_best_only=True)
# Guardar el mejor modelo
model_dir = r"/content/drive/MyDrive/Colab Notebooks/dataset-NARAJANAS"
model_filename = "naranjas_vgg16_softmax.keras" # Changed file extension to .keras
json_filename = "naranjas_vgg16_softmax.json"
model_path = [Link](model_dir, model_filename)
json_path = [Link](model_dir, json_filename)
model_checkpoint = ModelCheckpoint(model_path, monitor='val_loss',
save_best_only=True)
# Entrenar el modelo
history = [Link](
train_generator,
steps_per_epoch=nb_train_samples // batch_size,
epochs=epochs,
validation_data=validation_generator,
validation_steps=nb_validation_samples // batch_size,
callbacks=[early_stopping, model_checkpoint]
)
# Guardar el modelo en formato Keras y JSON
[Link](model_path)
model_json = model.to_json()
with open(json_path, "w") as json_file:
json_file.write(model_json)
# Guardar el modelo en formato HDF5
[Link]('/content/drive/MyDrive/Colab
Notebooks/dataset-NARAJANAS/naranjas_vgg16_softmax.h5')
import [Link] as plt
# Graficar la pérdida y precisión para las últimas épocas
[Link](figsize=(12, 6))
# Graficar la pérdida
[Link](1, 2, 1)
[Link]([Link]['loss'], label='Pérdida en Entrenamiento')
[Link]([Link]['val_loss'], label='Pérdida en Validación')
[Link]('Épocas')
[Link]('Pérdida')
[Link]()
[Link]('Pérdida durante el Entrenamiento')
# Graficar la precisión
[Link](1, 2, 2)
[Link]([Link]['accuracy'], label='Precisión en Entrenamiento')
[Link]([Link]['val_accuracy'], label='Precisión en Validación')
[Link]('Épocas')
[Link]('Precisión')
[Link]()
[Link]('Precisión durante el Entrenamiento')
[Link]()
# Ajustar Early Stopping si es necesario
from [Link] import EarlyStopping
early_stopping = EarlyStopping(monitor='val_loss', patience=10,
restore_best_weights=True)
# Evaluar el rendimiento en el conjunto de validación
val_loss, val_accuracy = [Link](validation_generator)
print(f"Validation Accuracy: {val_accuracy:.2f}")
print(f"Validation Loss: {val_loss:.2f}")
# Prueba con 10 imágenes nuevas y mostrar resultados
test_images_dir = r'/content/drive/MyDrive/Colab Notebooks/dataset-NARAJANAS/test'
plaga_images = [[Link](test_images_dir, 'plaga', img) for img in
[Link](test_images_dir + '/plaga')]
no_plaga_images = [[Link](test_images_dir, 'no_plaga', img) for img in
[Link](test_images_dir + '/no_plaga')]
# Combinar y seleccionar aleatoriamente 5 imágenes de cada clase
selected_images = [Link](plaga_images, 5) + [Link](no_plaga_images,
5)
[Link](selected_images)
[Link](figsize=(20, 10))
for i, img_path in enumerate(selected_images):
img_pred = image.load_img(img_path, target_size=(img_width, img_height))
img_pred = image.img_to_array(img_pred)
img_pred = np.expand_dims(img_pred, axis=0)
img_pred = img_pred / 255.0 # Normalizar
# Realizar la predicción
prediction = [Link](img_pred)
predicted_class = [Link](prediction, axis=1) # Obtener la clase con mayor
probabilidad
# Mostrar la imagen con su predicción
[Link](2, 5, i + 1)
img = [Link](img_path)
[Link](img)
[Link]('off')
actual_class = "Plaga" if 'plaga' in img_path else "No Plaga"
[Link](f"{actual_class}: {'Plaga' if predicted_class == 1 else 'No Plaga'}\
nProbabilidad: {prediction[0][predicted_class][0]:.2f}")
[Link]()
import [Link] as plt
# Suponiendo que `history` es el objeto devuelto por el método `fit` de Keras
# [Link]['loss'] y [Link]['val_loss'] son listas de pérdidas de
entrenamiento y validación
# [Link]['accuracy'] y [Link]['val_accuracy'] son listas de
precisión de entrenamiento y validación
epochs = range(1, len([Link]['loss']) + 1)
[Link](figsize=(14, 5))
# Gráfico de pérdida
[Link](1, 2, 1)
[Link](epochs, [Link]['loss'], 'bo-', label='Pérdida de Entrenamiento')
[Link](epochs, [Link]['val_loss'], 'ro-', label='Pérdida de Validación')
[Link]('Curva de Aprendizaje - Pérdida')
[Link]('Épocas')
[Link]('Pérdida')
[Link]()
[Link](True)
# Gráfico de precisión
[Link](1, 2, 2)
[Link](epochs, [Link]['accuracy'], 'bo-', label='Precisión de
Entrenamiento')
[Link](epochs, [Link]['val_accuracy'], 'ro-', label='Precisión de
Validación')
[Link]('Curva de Aprendizaje - Precisión')
[Link]('Épocas')
[Link]('Precisión')
[Link]()
[Link](True)
plt.tight_layout()
[Link]()
import [Link] as plt
# Datos de pérdida y precisión del entrenamiento
epochs = range(1, len([Link]['loss']) + 1)
[Link](figsize=(14, 5))
# Pérdida
[Link](1, 2, 1)
[Link](epochs, [Link]['loss'], 'bo-', label='Pérdida de Entrenamiento')
[Link](epochs, [Link]['val_loss'], 'ro-', label='Pérdida de Validación')
[Link]('Pérdida Durante el Entrenamiento')
[Link]('Épocas')
[Link]('Pérdida')
[Link]()
[Link](True)
# Precisión
[Link](1, 2, 2)
[Link](epochs, [Link]['accuracy'], 'bo-', label='Precisión de
Entrenamiento')
[Link](epochs, [Link]['val_accuracy'], 'ro-', label='Precisión de
Validación')
[Link]('Precisión Durante el Entrenamiento')
[Link]('Épocas')
[Link]('Precisión')
[Link]()
[Link](True)
plt.tight_layout()
[Link]()
import [Link] as plt
import numpy as np
def plot_histogram(errors):
# Asegúrate de que `errors` sea un array de NumPy y no contenga NaN o infinitos
errors = [Link](errors)
errors = errors[[Link](errors)]
[Link](figsize=(10, 6))
[Link](errors, bins=30, edgecolor='k', alpha=0.7)
[Link]('Histograma de Errores')
[Link]('Error')
[Link]('Frecuencia')
[Link](True)
[Link]()
def plot_learning_curves(history):
epochs = range(1, len([Link]['loss']) + 1)
[Link](figsize=(14, 5))
# Gráfico de pérdida
[Link](1, 2, 1)
[Link](epochs, [Link]['loss'], 'bo-', label='Pérdida de
Entrenamiento')
[Link](epochs, [Link]['val_loss'], 'ro-', label='Pérdida de
Validación')
[Link]('Curva de Aprendizaje - Pérdida')
[Link]('Épocas')
[Link]('Pérdida')
[Link]()
[Link](True)
# Gráfico de precisión
[Link](1, 2, 2)
[Link](epochs, [Link]['accuracy'], 'bo-', label='Precisión de
Entrenamiento')
[Link](epochs, [Link]['val_accuracy'], 'ro-', label='Precisión de
Validación')
[Link]('Curva de Aprendizaje - Precisión')
[Link]('Épocas')
[Link]('Precisión')
[Link]()
[Link](True)
plt.tight_layout()
[Link]()
def plot_loss_and_accuracy(history):
epochs = range(1, len([Link]['loss']) + 1)
[Link](figsize=(14, 5))
# Pérdida
[Link](1, 2, 1)
[Link](epochs, [Link]['loss'], 'bo-', label='Pérdida de
Entrenamiento')
[Link](epochs, [Link]['val_loss'], 'ro-', label='Pérdida de
Validación')
[Link]('Pérdida Durante el Entrenamiento')
[Link]('Épocas')
[Link]('Pérdida')
[Link]()
[Link](True)
# Precisión
[Link](1, 2, 2)
[Link](epochs, [Link]['accuracy'], 'bo-', label='Precisión de
Entrenamiento')
[Link](epochs, [Link]['val_accuracy'], 'ro-', label='Precisión de
Validación')
[Link]('Precisión Durante el Entrenamiento')
[Link]('Épocas')
[Link]('Precisión')
[Link]()
[Link](True)
plt.tight_layout()
[Link]()
# Ejemplo de uso
if __name__ == "__main__":
# Datos de ejemplo para errores (debes reemplazar esto con tus datos reales)
errors = [0.1, 0.2, 0.15, 0.3, 0.25, 0.2, 0.1, 0.05, 0.4, 0.3]
plot_histogram(errors)
# Supongamos que tienes un objeto `history` del entrenamiento en Keras
# history = [Link](...) # Aquí es donde entrenas tu modelo y obtienes el
historial
# plot_learning_curves(history)
# plot_loss_and_accuracy(history)
import [Link] as plt
import seaborn as sns
import numpy as np
from [Link] import confusion_matrix, roc_curve, auc
from [Link] import make_classification
from sklearn.model_selection import train_test_split
from [Link] import Sequential
from [Link] import Dense
from [Link] import Adam
# Generamos datos de ejemplo
X, y = make_classification(n_samples=1000, n_classes=2, n_features=20,
random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)
# Creamos un modelo simple
model = Sequential([
Dense(64, activation='relu', input_shape=(20,)),
Dense(32, activation='relu'),
Dense(1, activation='sigmoid')
])
[Link](optimizer=Adam(), loss='binary_crossentropy', metrics=['accuracy'])
# Entrenamos el modelo
history = [Link](X_train, y_train, validation_split=0.2, epochs=50,
batch_size=32, verbose=0)
# Obtenemos predicciones
y_pred = [Link](X_test)
y_pred_classes = (y_pred > 0.5).astype(int).reshape(-1)
# 1. Gráfica de pérdida y precisión durante el entrenamiento
[Link](figsize=(12, 4))
[Link](1, 2, 1)
[Link]([Link]['loss'], label='Pérdida de entrenamiento')
[Link]([Link]['val_loss'], label='Pérdida de validación')
[Link]('Pérdida del modelo')
[Link]('Época')
[Link]('Pérdida')
[Link]()
[Link](1, 2, 2)
[Link]([Link]['accuracy'], label='Precisión de entrenamiento')
[Link]([Link]['val_accuracy'], label='Precisión de validación')
[Link]('Precisión del modelo')
[Link]('Época')
[Link]('Precisión')
[Link]()
plt.tight_layout()
[Link]()
# 2. Matriz de confusión
cm = confusion_matrix(y_test, y_pred_classes)
[Link](figsize=(8, 6))
[Link](cm, annot=True, fmt='d', cmap='Blues')
[Link]('Matriz de Confusión')
[Link]('Predicción')
[Link]('Verdadero')
[Link]()
# 3. Curva ROC
fpr, tpr, _ = roc_curve(y_test, y_pred)
roc_auc = auc(fpr, tpr)
[Link](figsize=(8, 6))
[Link](fpr, tpr, color='darkorange', lw=2, label=f'Curva ROC (AUC =
{roc_auc:.2f})')
[Link]([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
[Link]([0.0, 1.0])
[Link]([0.0, 1.05])
[Link]('Tasa de Falsos Positivos')
[Link]('Tasa de Verdaderos Positivos')
[Link]('Curva Característica Operativa del Receptor (ROC)')
[Link](loc="lower right")
[Link]()
# 4. Distribución de las predicciones
[Link](figsize=(10, 6))
[Link](y_pred, bins=50, kde=True)
[Link]('Distribución de las Probabilidades de Predicción')
[Link]('Probabilidad de Predicción')
[Link]('Frecuencia')
[Link]()
a import tensorflow as tf
# Convertir el modelo a TensorFlow Lite
converter = [Link].from_keras_model(model)
tflite_model = [Link]()
# Guardar el modelo TFLite en un archivo
with open('/content/drive/MyDrive/Colab
Notebooks/dataset-NARAJANAS/basic_model.tflite', 'wb') as f:
[Link](tflite_model)
print("Modelo convertido a TensorFlow Lite exitosamente.")
