Capítulo 9: Explorando Modelos de Difusión
Ejercicios Prácticos
Esta sección proporciona ejercicios prácticos para reforzar tu comprensión de los modelos de difusión y su evaluación. Cada ejercicio incluye una declaración del problema y una solución con ejemplos de código donde sea aplicable.
Ejercicio 1: Implementar el Proceso de Difusión Directa
Declaración del Problema: Implementar el proceso de difusión directa para agregar ruido Gaussiano a un conjunto de datos de entrada durante una serie de pasos temporales. Visualizar la transformación de los datos en cada paso.
Solución:
import numpy as np
import matplotlib.pyplot as plt
def forward_diffusion(data, num_steps, noise_scale=0.1):
"""
Applies forward diffusion process to the data.
Parameters:
- data: The original data (e.g., an image represented as a NumPy array).
- num_steps: The number of diffusion steps.
- noise_scale: The scale of the Gaussian noise to be added at each step.
Returns:
- A list of noisy data at each diffusion step.
"""
noisy_data = [data]
for step in range(num_steps):
noise = np.random.normal(scale=noise_scale, size=data.shape)
noisy_data.append(noisy_data[-1] + noise)
return noisy_data
# Generate a simple 1D signal
data = np.sin(np.linspace(0, 2 * np.pi, 100))
noisy_data = forward_diffusion(data, num_steps=10, noise_scale=0.1)
# Plot the noisy data
plt.figure(figsize=(10, 6))
for i, noisy in enumerate(noisy_data):
plt.plot(noisy, label=f"Step {i}")
plt.legend()
plt.title("Forward Diffusion Process")
plt.show()Ejercicio 2: Construir y Entrenar un Modelo de Desenruidecimiento Simple
Declaración del Problema: Construir un modelo de desenruidecimiento simple utilizando una red neuronal y entrenarlo para eliminar el ruido de los datos ruidosos generados en el Ejercicio 1.
Solución:
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Flatten, Reshape
from tensorflow.keras.models import Model
def build_denoising_network(input_shape):
"""
Builds a simple denoising network.
Parameters:
- input_shape: Shape of the input data.
Returns:
- A Keras model for denoising.
"""
inputs = Input(shape=input_shape)
x = Flatten()(inputs)
x = Dense(128, activation='relu')(x)
x = Dense(np.prod(input_shape), activation='linear')(x)
outputs = Reshape(input_shape)(x)
return Model(inputs, outputs)
# Example usage with 1D data
input_shape = (100,)
denoising_network = build_denoising_network(input_shape)
denoising_network.compile(optimizer='adam', loss='mse')
# Generate synthetic training data
num_samples = 1000
data_length = 100
training_data = generate_synthetic_data(num_samples, data_length)
# Apply forward diffusion to the training data
num_steps = 10
noise_scale = 0.1
noisy_training_data = [forward_diffusion(data, num_steps, noise_scale) for data in training_data]
# Prepare data for training
X_train = np.array([noisy[-1] for noisy in noisy_training_data]) # Final noisy state
y_train = np.array([data for data in training_data]) # Original data
# Train the denoising model
history = denoising_network.fit(X_train, y_train, epochs=20, batch_size=32, validation_split=0.2)
# Plot the training and validation loss
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.title('Training and Validation Loss')
plt.show()Ejercicio 3: Evaluar el Modelo Usando MSE
Declaración del Problema: Evaluar el modelo de desenruidecimiento entrenado utilizando la métrica de Error Cuadrático Medio (MSE) en un conjunto de datos de prueba separado.
Solución:
import numpy as np
from sklearn.metrics import mean_squared_error
# Generate synthetic test data
test_data = generate_synthetic_data(100, data_length)
noisy_test_data = [forward_diffusion(data, num_steps, noise_scale) for data in test_data]
X_test = np.array([noisy[-1] for noisy in noisy_test_data])
y_test = np.array([data for data in test_data])
# Predict denoised data
denoised_data = denoising_network.predict(X_test)
# Calculate MSE
mse = mean_squared_error(y_test.flatten(), denoised_data.flatten())
print(f"MSE: {mse}")Ejercicio 4: Calcular la Distancia de Incepción de Fréchet (FID)
Declaración del Problema: Calcular la Distancia de Incepción de Fréchet (FID) para evaluar la calidad y diversidad de los datos desenruidecidos generados por el modelo.
Solución:
from scipy.linalg import sqrtm
from numpy import cov, trace, iscomplexobj
def calculate_fid(real_images, generated_images):
# Calculate the mean and covariance of real and generated images
mu1, sigma1 = real_images.mean(axis=0), cov(real_images, rowvar=False)
mu2, sigma2 = generated_images.mean(axis=0), cov(generated_images, rowvar=False)
# Calculate the sum of squared differences between means
ssdiff = np.sum((mu1 - mu2) ** 2.0)
# Calculate the square root of the product of covariances
covmean = sqrtm(sigma1.dot(sigma2))
if iscomplexobj(covmean):
covmean = covmean.real
# Calculate the FID score
fid = ssdiff + trace(sigma1 + sigma2 - 2.0 * covmean)
return fid
# Assume denoised_data and y_test are the denoised and original data, respectively
fid_score = calculate_fid(y_test.reshape(100, -1), denoised_data.reshape(100, -1))
print(f"FID Score: {fid_score}")Ejercicio 5: Inspección Visual de Datos Desenmascarados
Declaración del Problema: Inspeccionar visualmente los datos desenmascarados generados por el modelo para evaluar su calidad y coherencia en comparación con los datos originales y ruidosos.
Solución:
import matplotlib.pyplot as plt
# Generate a sample for visual inspection
sample_idx = 0
plt.figure(figsize=(12, 4))
plt.subplot(1, 3, 1)
plt.plot(y_test[sample_idx], label='Original Data')
plt.title('Original Data')
plt.subplot(1, 3, 2)
plt.plot(X_test[sample_idx], label='Noisy Data')
plt.title('Noisy Data')
plt.subplot(1, 3, 3)
plt.plot(denoised_data[sample_idx], label='Denoised Data')
plt.title('Denoised Data')
plt.show()Estos ejercicios prácticos proporcionan una experiencia práctica con modelos de difusión y su evaluación. Al implementar el proceso de difusión hacia adelante, construir y entrenar un modelo de desenmascaramiento, y evaluar el modelo utilizando métodos cuantitativos y cualitativos, puedes profundizar tu comprensión de cómo funcionan los modelos de difusión y cómo evaluar su desempeño.
Cada ejercicio está diseñado para reforzar conceptos y técnicas clave, ayudándote a aplicar modelos de difusión de manera efectiva en varias tareas generativas.
Ejercicios Prácticos
Esta sección proporciona ejercicios prácticos para reforzar tu comprensión de los modelos de difusión y su evaluación. Cada ejercicio incluye una declaración del problema y una solución con ejemplos de código donde sea aplicable.
Ejercicio 1: Implementar el Proceso de Difusión Directa
Declaración del Problema: Implementar el proceso de difusión directa para agregar ruido Gaussiano a un conjunto de datos de entrada durante una serie de pasos temporales. Visualizar la transformación de los datos en cada paso.
Solución:
import numpy as np
import matplotlib.pyplot as plt
def forward_diffusion(data, num_steps, noise_scale=0.1):
"""
Applies forward diffusion process to the data.
Parameters:
- data: The original data (e.g., an image represented as a NumPy array).
- num_steps: The number of diffusion steps.
- noise_scale: The scale of the Gaussian noise to be added at each step.
Returns:
- A list of noisy data at each diffusion step.
"""
noisy_data = [data]
for step in range(num_steps):
noise = np.random.normal(scale=noise_scale, size=data.shape)
noisy_data.append(noisy_data[-1] + noise)
return noisy_data
# Generate a simple 1D signal
data = np.sin(np.linspace(0, 2 * np.pi, 100))
noisy_data = forward_diffusion(data, num_steps=10, noise_scale=0.1)
# Plot the noisy data
plt.figure(figsize=(10, 6))
for i, noisy in enumerate(noisy_data):
plt.plot(noisy, label=f"Step {i}")
plt.legend()
plt.title("Forward Diffusion Process")
plt.show()Ejercicio 2: Construir y Entrenar un Modelo de Desenruidecimiento Simple
Declaración del Problema: Construir un modelo de desenruidecimiento simple utilizando una red neuronal y entrenarlo para eliminar el ruido de los datos ruidosos generados en el Ejercicio 1.
Solución:
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Flatten, Reshape
from tensorflow.keras.models import Model
def build_denoising_network(input_shape):
"""
Builds a simple denoising network.
Parameters:
- input_shape: Shape of the input data.
Returns:
- A Keras model for denoising.
"""
inputs = Input(shape=input_shape)
x = Flatten()(inputs)
x = Dense(128, activation='relu')(x)
x = Dense(np.prod(input_shape), activation='linear')(x)
outputs = Reshape(input_shape)(x)
return Model(inputs, outputs)
# Example usage with 1D data
input_shape = (100,)
denoising_network = build_denoising_network(input_shape)
denoising_network.compile(optimizer='adam', loss='mse')
# Generate synthetic training data
num_samples = 1000
data_length = 100
training_data = generate_synthetic_data(num_samples, data_length)
# Apply forward diffusion to the training data
num_steps = 10
noise_scale = 0.1
noisy_training_data = [forward_diffusion(data, num_steps, noise_scale) for data in training_data]
# Prepare data for training
X_train = np.array([noisy[-1] for noisy in noisy_training_data]) # Final noisy state
y_train = np.array([data for data in training_data]) # Original data
# Train the denoising model
history = denoising_network.fit(X_train, y_train, epochs=20, batch_size=32, validation_split=0.2)
# Plot the training and validation loss
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.title('Training and Validation Loss')
plt.show()Ejercicio 3: Evaluar el Modelo Usando MSE
Declaración del Problema: Evaluar el modelo de desenruidecimiento entrenado utilizando la métrica de Error Cuadrático Medio (MSE) en un conjunto de datos de prueba separado.
Solución:
import numpy as np
from sklearn.metrics import mean_squared_error
# Generate synthetic test data
test_data = generate_synthetic_data(100, data_length)
noisy_test_data = [forward_diffusion(data, num_steps, noise_scale) for data in test_data]
X_test = np.array([noisy[-1] for noisy in noisy_test_data])
y_test = np.array([data for data in test_data])
# Predict denoised data
denoised_data = denoising_network.predict(X_test)
# Calculate MSE
mse = mean_squared_error(y_test.flatten(), denoised_data.flatten())
print(f"MSE: {mse}")Ejercicio 4: Calcular la Distancia de Incepción de Fréchet (FID)
Declaración del Problema: Calcular la Distancia de Incepción de Fréchet (FID) para evaluar la calidad y diversidad de los datos desenruidecidos generados por el modelo.
Solución:
from scipy.linalg import sqrtm
from numpy import cov, trace, iscomplexobj
def calculate_fid(real_images, generated_images):
# Calculate the mean and covariance of real and generated images
mu1, sigma1 = real_images.mean(axis=0), cov(real_images, rowvar=False)
mu2, sigma2 = generated_images.mean(axis=0), cov(generated_images, rowvar=False)
# Calculate the sum of squared differences between means
ssdiff = np.sum((mu1 - mu2) ** 2.0)
# Calculate the square root of the product of covariances
covmean = sqrtm(sigma1.dot(sigma2))
if iscomplexobj(covmean):
covmean = covmean.real
# Calculate the FID score
fid = ssdiff + trace(sigma1 + sigma2 - 2.0 * covmean)
return fid
# Assume denoised_data and y_test are the denoised and original data, respectively
fid_score = calculate_fid(y_test.reshape(100, -1), denoised_data.reshape(100, -1))
print(f"FID Score: {fid_score}")Ejercicio 5: Inspección Visual de Datos Desenmascarados
Declaración del Problema: Inspeccionar visualmente los datos desenmascarados generados por el modelo para evaluar su calidad y coherencia en comparación con los datos originales y ruidosos.
Solución:
import matplotlib.pyplot as plt
# Generate a sample for visual inspection
sample_idx = 0
plt.figure(figsize=(12, 4))
plt.subplot(1, 3, 1)
plt.plot(y_test[sample_idx], label='Original Data')
plt.title('Original Data')
plt.subplot(1, 3, 2)
plt.plot(X_test[sample_idx], label='Noisy Data')
plt.title('Noisy Data')
plt.subplot(1, 3, 3)
plt.plot(denoised_data[sample_idx], label='Denoised Data')
plt.title('Denoised Data')
plt.show()Estos ejercicios prácticos proporcionan una experiencia práctica con modelos de difusión y su evaluación. Al implementar el proceso de difusión hacia adelante, construir y entrenar un modelo de desenmascaramiento, y evaluar el modelo utilizando métodos cuantitativos y cualitativos, puedes profundizar tu comprensión de cómo funcionan los modelos de difusión y cómo evaluar su desempeño.
Cada ejercicio está diseñado para reforzar conceptos y técnicas clave, ayudándote a aplicar modelos de difusión de manera efectiva en varias tareas generativas.
Ejercicios Prácticos
Esta sección proporciona ejercicios prácticos para reforzar tu comprensión de los modelos de difusión y su evaluación. Cada ejercicio incluye una declaración del problema y una solución con ejemplos de código donde sea aplicable.
Ejercicio 1: Implementar el Proceso de Difusión Directa
Declaración del Problema: Implementar el proceso de difusión directa para agregar ruido Gaussiano a un conjunto de datos de entrada durante una serie de pasos temporales. Visualizar la transformación de los datos en cada paso.
Solución:
import numpy as np
import matplotlib.pyplot as plt
def forward_diffusion(data, num_steps, noise_scale=0.1):
"""
Applies forward diffusion process to the data.
Parameters:
- data: The original data (e.g., an image represented as a NumPy array).
- num_steps: The number of diffusion steps.
- noise_scale: The scale of the Gaussian noise to be added at each step.
Returns:
- A list of noisy data at each diffusion step.
"""
noisy_data = [data]
for step in range(num_steps):
noise = np.random.normal(scale=noise_scale, size=data.shape)
noisy_data.append(noisy_data[-1] + noise)
return noisy_data
# Generate a simple 1D signal
data = np.sin(np.linspace(0, 2 * np.pi, 100))
noisy_data = forward_diffusion(data, num_steps=10, noise_scale=0.1)
# Plot the noisy data
plt.figure(figsize=(10, 6))
for i, noisy in enumerate(noisy_data):
plt.plot(noisy, label=f"Step {i}")
plt.legend()
plt.title("Forward Diffusion Process")
plt.show()Ejercicio 2: Construir y Entrenar un Modelo de Desenruidecimiento Simple
Declaración del Problema: Construir un modelo de desenruidecimiento simple utilizando una red neuronal y entrenarlo para eliminar el ruido de los datos ruidosos generados en el Ejercicio 1.
Solución:
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Flatten, Reshape
from tensorflow.keras.models import Model
def build_denoising_network(input_shape):
"""
Builds a simple denoising network.
Parameters:
- input_shape: Shape of the input data.
Returns:
- A Keras model for denoising.
"""
inputs = Input(shape=input_shape)
x = Flatten()(inputs)
x = Dense(128, activation='relu')(x)
x = Dense(np.prod(input_shape), activation='linear')(x)
outputs = Reshape(input_shape)(x)
return Model(inputs, outputs)
# Example usage with 1D data
input_shape = (100,)
denoising_network = build_denoising_network(input_shape)
denoising_network.compile(optimizer='adam', loss='mse')
# Generate synthetic training data
num_samples = 1000
data_length = 100
training_data = generate_synthetic_data(num_samples, data_length)
# Apply forward diffusion to the training data
num_steps = 10
noise_scale = 0.1
noisy_training_data = [forward_diffusion(data, num_steps, noise_scale) for data in training_data]
# Prepare data for training
X_train = np.array([noisy[-1] for noisy in noisy_training_data]) # Final noisy state
y_train = np.array([data for data in training_data]) # Original data
# Train the denoising model
history = denoising_network.fit(X_train, y_train, epochs=20, batch_size=32, validation_split=0.2)
# Plot the training and validation loss
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.title('Training and Validation Loss')
plt.show()Ejercicio 3: Evaluar el Modelo Usando MSE
Declaración del Problema: Evaluar el modelo de desenruidecimiento entrenado utilizando la métrica de Error Cuadrático Medio (MSE) en un conjunto de datos de prueba separado.
Solución:
import numpy as np
from sklearn.metrics import mean_squared_error
# Generate synthetic test data
test_data = generate_synthetic_data(100, data_length)
noisy_test_data = [forward_diffusion(data, num_steps, noise_scale) for data in test_data]
X_test = np.array([noisy[-1] for noisy in noisy_test_data])
y_test = np.array([data for data in test_data])
# Predict denoised data
denoised_data = denoising_network.predict(X_test)
# Calculate MSE
mse = mean_squared_error(y_test.flatten(), denoised_data.flatten())
print(f"MSE: {mse}")Ejercicio 4: Calcular la Distancia de Incepción de Fréchet (FID)
Declaración del Problema: Calcular la Distancia de Incepción de Fréchet (FID) para evaluar la calidad y diversidad de los datos desenruidecidos generados por el modelo.
Solución:
from scipy.linalg import sqrtm
from numpy import cov, trace, iscomplexobj
def calculate_fid(real_images, generated_images):
# Calculate the mean and covariance of real and generated images
mu1, sigma1 = real_images.mean(axis=0), cov(real_images, rowvar=False)
mu2, sigma2 = generated_images.mean(axis=0), cov(generated_images, rowvar=False)
# Calculate the sum of squared differences between means
ssdiff = np.sum((mu1 - mu2) ** 2.0)
# Calculate the square root of the product of covariances
covmean = sqrtm(sigma1.dot(sigma2))
if iscomplexobj(covmean):
covmean = covmean.real
# Calculate the FID score
fid = ssdiff + trace(sigma1 + sigma2 - 2.0 * covmean)
return fid
# Assume denoised_data and y_test are the denoised and original data, respectively
fid_score = calculate_fid(y_test.reshape(100, -1), denoised_data.reshape(100, -1))
print(f"FID Score: {fid_score}")Ejercicio 5: Inspección Visual de Datos Desenmascarados
Declaración del Problema: Inspeccionar visualmente los datos desenmascarados generados por el modelo para evaluar su calidad y coherencia en comparación con los datos originales y ruidosos.
Solución:
import matplotlib.pyplot as plt
# Generate a sample for visual inspection
sample_idx = 0
plt.figure(figsize=(12, 4))
plt.subplot(1, 3, 1)
plt.plot(y_test[sample_idx], label='Original Data')
plt.title('Original Data')
plt.subplot(1, 3, 2)
plt.plot(X_test[sample_idx], label='Noisy Data')
plt.title('Noisy Data')
plt.subplot(1, 3, 3)
plt.plot(denoised_data[sample_idx], label='Denoised Data')
plt.title('Denoised Data')
plt.show()Estos ejercicios prácticos proporcionan una experiencia práctica con modelos de difusión y su evaluación. Al implementar el proceso de difusión hacia adelante, construir y entrenar un modelo de desenmascaramiento, y evaluar el modelo utilizando métodos cuantitativos y cualitativos, puedes profundizar tu comprensión de cómo funcionan los modelos de difusión y cómo evaluar su desempeño.
Cada ejercicio está diseñado para reforzar conceptos y técnicas clave, ayudándote a aplicar modelos de difusión de manera efectiva en varias tareas generativas.
Ejercicios Prácticos
Esta sección proporciona ejercicios prácticos para reforzar tu comprensión de los modelos de difusión y su evaluación. Cada ejercicio incluye una declaración del problema y una solución con ejemplos de código donde sea aplicable.
Ejercicio 1: Implementar el Proceso de Difusión Directa
Declaración del Problema: Implementar el proceso de difusión directa para agregar ruido Gaussiano a un conjunto de datos de entrada durante una serie de pasos temporales. Visualizar la transformación de los datos en cada paso.
Solución:
import numpy as np
import matplotlib.pyplot as plt
def forward_diffusion(data, num_steps, noise_scale=0.1):
"""
Applies forward diffusion process to the data.
Parameters:
- data: The original data (e.g., an image represented as a NumPy array).
- num_steps: The number of diffusion steps.
- noise_scale: The scale of the Gaussian noise to be added at each step.
Returns:
- A list of noisy data at each diffusion step.
"""
noisy_data = [data]
for step in range(num_steps):
noise = np.random.normal(scale=noise_scale, size=data.shape)
noisy_data.append(noisy_data[-1] + noise)
return noisy_data
# Generate a simple 1D signal
data = np.sin(np.linspace(0, 2 * np.pi, 100))
noisy_data = forward_diffusion(data, num_steps=10, noise_scale=0.1)
# Plot the noisy data
plt.figure(figsize=(10, 6))
for i, noisy in enumerate(noisy_data):
plt.plot(noisy, label=f"Step {i}")
plt.legend()
plt.title("Forward Diffusion Process")
plt.show()Ejercicio 2: Construir y Entrenar un Modelo de Desenruidecimiento Simple
Declaración del Problema: Construir un modelo de desenruidecimiento simple utilizando una red neuronal y entrenarlo para eliminar el ruido de los datos ruidosos generados en el Ejercicio 1.
Solución:
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense, Flatten, Reshape
from tensorflow.keras.models import Model
def build_denoising_network(input_shape):
"""
Builds a simple denoising network.
Parameters:
- input_shape: Shape of the input data.
Returns:
- A Keras model for denoising.
"""
inputs = Input(shape=input_shape)
x = Flatten()(inputs)
x = Dense(128, activation='relu')(x)
x = Dense(np.prod(input_shape), activation='linear')(x)
outputs = Reshape(input_shape)(x)
return Model(inputs, outputs)
# Example usage with 1D data
input_shape = (100,)
denoising_network = build_denoising_network(input_shape)
denoising_network.compile(optimizer='adam', loss='mse')
# Generate synthetic training data
num_samples = 1000
data_length = 100
training_data = generate_synthetic_data(num_samples, data_length)
# Apply forward diffusion to the training data
num_steps = 10
noise_scale = 0.1
noisy_training_data = [forward_diffusion(data, num_steps, noise_scale) for data in training_data]
# Prepare data for training
X_train = np.array([noisy[-1] for noisy in noisy_training_data]) # Final noisy state
y_train = np.array([data for data in training_data]) # Original data
# Train the denoising model
history = denoising_network.fit(X_train, y_train, epochs=20, batch_size=32, validation_split=0.2)
# Plot the training and validation loss
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.title('Training and Validation Loss')
plt.show()Ejercicio 3: Evaluar el Modelo Usando MSE
Declaración del Problema: Evaluar el modelo de desenruidecimiento entrenado utilizando la métrica de Error Cuadrático Medio (MSE) en un conjunto de datos de prueba separado.
Solución:
import numpy as np
from sklearn.metrics import mean_squared_error
# Generate synthetic test data
test_data = generate_synthetic_data(100, data_length)
noisy_test_data = [forward_diffusion(data, num_steps, noise_scale) for data in test_data]
X_test = np.array([noisy[-1] for noisy in noisy_test_data])
y_test = np.array([data for data in test_data])
# Predict denoised data
denoised_data = denoising_network.predict(X_test)
# Calculate MSE
mse = mean_squared_error(y_test.flatten(), denoised_data.flatten())
print(f"MSE: {mse}")Ejercicio 4: Calcular la Distancia de Incepción de Fréchet (FID)
Declaración del Problema: Calcular la Distancia de Incepción de Fréchet (FID) para evaluar la calidad y diversidad de los datos desenruidecidos generados por el modelo.
Solución:
from scipy.linalg import sqrtm
from numpy import cov, trace, iscomplexobj
def calculate_fid(real_images, generated_images):
# Calculate the mean and covariance of real and generated images
mu1, sigma1 = real_images.mean(axis=0), cov(real_images, rowvar=False)
mu2, sigma2 = generated_images.mean(axis=0), cov(generated_images, rowvar=False)
# Calculate the sum of squared differences between means
ssdiff = np.sum((mu1 - mu2) ** 2.0)
# Calculate the square root of the product of covariances
covmean = sqrtm(sigma1.dot(sigma2))
if iscomplexobj(covmean):
covmean = covmean.real
# Calculate the FID score
fid = ssdiff + trace(sigma1 + sigma2 - 2.0 * covmean)
return fid
# Assume denoised_data and y_test are the denoised and original data, respectively
fid_score = calculate_fid(y_test.reshape(100, -1), denoised_data.reshape(100, -1))
print(f"FID Score: {fid_score}")Ejercicio 5: Inspección Visual de Datos Desenmascarados
Declaración del Problema: Inspeccionar visualmente los datos desenmascarados generados por el modelo para evaluar su calidad y coherencia en comparación con los datos originales y ruidosos.
Solución:
import matplotlib.pyplot as plt
# Generate a sample for visual inspection
sample_idx = 0
plt.figure(figsize=(12, 4))
plt.subplot(1, 3, 1)
plt.plot(y_test[sample_idx], label='Original Data')
plt.title('Original Data')
plt.subplot(1, 3, 2)
plt.plot(X_test[sample_idx], label='Noisy Data')
plt.title('Noisy Data')
plt.subplot(1, 3, 3)
plt.plot(denoised_data[sample_idx], label='Denoised Data')
plt.title('Denoised Data')
plt.show()Estos ejercicios prácticos proporcionan una experiencia práctica con modelos de difusión y su evaluación. Al implementar el proceso de difusión hacia adelante, construir y entrenar un modelo de desenmascaramiento, y evaluar el modelo utilizando métodos cuantitativos y cualitativos, puedes profundizar tu comprensión de cómo funcionan los modelos de difusión y cómo evaluar su desempeño.
Cada ejercicio está diseñado para reforzar conceptos y técnicas clave, ayudándote a aplicar modelos de difusión de manera efectiva en varias tareas generativas.