Resultado de predicción de regresión de imagen de CNN

importar numpy como np
importar pandas como pd
de la ruta import Path
import os.path

desde sklearn.model_selection importar train_test_split

import tensorflow como tf

desde sklearn.metrics importar r2_score

desde keras.applications.efficientnet importar EfficientNetB3
import gc
desde keras.models import Sequential
desde keras import layers, modelos

desde keras importar Input
desde keras.models importar Model
desde keras.preprocessing.image import ImageDataGenerator
desde keras importar optimizers, initializers, regularizers, metrics
desde keras.callbacks import ModelCheckpoint
importar os
desde glob importar glob
desde PIL importar imagen
importar matplotlib.pyplot como plt
importar numpy como np
desde tensorflow.keras import optimizers
desde keras.layers importar Conv2D,MaxPool2D,GlobalAveragePooling2D,AveragePooling2D
desde keras.layers importar Denso,Dropout,Activation,Aplanar
importar sys

Fuente del repositorio: https://github.com/qubvel/efficientnet

sys.path.append(os.path.abspath (‘../input/efficientnet/efficientnet-master/efficientnet-master/’))
desde tensorflow.keras.callbacks importar EarlyStopping, ReduceLROnPlateau

image_dir = Path (‘/ contenido / unidad MyDrive / procesado’)

filepaths = pd.Series (lista (imagen_dir.glob (r ‘** / * .jpg’)), name = ‘Filepath’).astype (str)

TS = pd.Series (ordenado ([int (l.split (‘TS_’) [1].split (‘/ pre’) [0]) para l en filepaths]), name = ‘TS’). astype (np.int)
imágenes = pd.concat ([filepaths, TS], axis = 1). muestra (frac = 1.0, aleatoria_estado = 1) .reset_index (drop = True)

image_df = imágenes. muestra (2020, aleatoria_estado = 1) .reset_index (drop = True)

train_df, test_df = train_test_split (image_df, train_size = 0.7, shuffle = True, random_state = 1)

train_generator = tf.keras.preprocessing.image.ImageDataGenerator (
rescale = 1./255,
validation_split = 0.2
)

test_generator = tf.keras.preprocessing.image.ImageDataGenerator (
rescale = 1./255
)

train_input = train_generator.flow_from_dataframe (
dataframe = train_df,
x_col = ‘Filepath’,
y_col = ‘TS’,
target_size = (256, 256),
color_mode = ‘escala de grises’,
class_mode = ‘bruto’,
batch_size = 1,
shuffle = True,
semilla = 42,
subset = ‘entrenamiento’
)

val_input = train_generator.flow_from_dataframe (
dataframe = train_df,
x_col = ‘Filepath’,
y_col = ‘TS’,
target_size = (256, 256),
color_mode = ‘escala de grises’,
class_mode = ‘bruto’,
batch_size = 1,
shuffle = True,
semilla = 42,
subset = ‘validación’
)

test_input = test_generator.flow_from_dataframe (
dataframe = test_df,
x_col = ‘Filepath’,
y_col = ‘TS’,
target_size = (256, 256),
color_mode = ‘escala de grises’,
class_mode = ‘bruto’,
batch_size = 1,
shuffle = False
)

entradas = tf.keras.Input (forma = (256, 256, 1))
x = tf.keras.layers.Conv2D (filtros = 32, kernel_size = (3, 3), activation = ‘relu’) (entradas)
x = tf.keras.layers.Conv2D (filtros = 32, kernel_size = (3, 3), activation = ‘relu’) (x)
x = tf.keras.layers.MaxPool2D () (x)
x = tf.keras.layers.Conv2D (filtros = 64, kernel_size = (3, 3), activation = ‘relu’) (x)
x = tf.keras.layers.Conv2D (filtros = 64, kernel_size = (3, 3), activation = ‘relu’) (x)
x = tf.keras.layers.MaxPool2D () (x)
x = tf.keras.layers.Conv2D (filtros = 128, kernel_size = (3, 3), activation = ‘relu’) (x)
x = tf.keras.layers.Conv2D (filtros = 128, kernel_size = (3, 3), activation = ‘relu’) (x)
x = tf.keras.layers.MaxPool2D () (x)
x = tf.keras.layers.Flatten () (x)
x = tf.keras.layers.Dense (128, inicializador_kernel = ‘he_normal’) (x)
x = tf.keras.layers.Dense (64, inicializador_kernel = ‘he_normal’) (x)

salidas = tf.keras.layers.Dense (1, activation = ‘lineal’) (x)

modelo = tf.keras.Model (entradas = entradas, salidas = salidas)

modelo. compile (
optimizador = ‘adam’,
pérdida = ‘mae’
)

history = model.fit (
train_input,
validation_data = val_input,
épocas = 10,
callbacks = [
tf.keras.callbacks.EarlyStopping (
monitor = ‘val_loss’,
paciencia = 5,
restore_best_weights = True
)
]
)

#Resultados
predicted_TS = np.squeeze (modelo.predict (test_input))
true_TS = test_input.labels

rmse = np.sqrt (modelo.evaluate (test_input, verbose = 0))
print (” Test RMSE: {:.5f}”.format (rmse))

r2 = r2_score (true_TS, predicted_TS)
print (“Test R^2 Score: {:.5f}”.format (r2))

null_rmse = np.sqrt (np.sum ((true_TS – np.mean (true_TS)) ** 2) / len (true_TS))
print (“Null / Baseline Model Test RMSE: {:.5f}”.format (null_rmse))