added codes

Author: mhjensen

doc/src/week8/programs/AEkerasTF.py

@@ -0,0 +1,68 @@
+### Autoencoder Implementation in TensorFlow/Keras
+import numpy as np
+import matplotlib.pyplot as plt
+from tensorflow import keras
+from tensorflow.keras import layers
+from tensorflow.keras.datasets import mnist
+
+# Load MNIST dataset
+(x_train, _), (x_test, _) = mnist.load_data()
+
+# Normalize the images to [0, 1] range and reshape them to (num_samples, 28*28)
+x_train = x_train.astype('float32') / 255.
+x_test = x_test.astype('float32') / 255.
+x_train = x_train.reshape((len(x_train), -1))
+x_test = x_test.reshape((len(x_test), -1))
+
+# Define the Autoencoder Model
+input_dim = x_train.shape[1]
+encoding_dim = 64  # Dimension of the encoding layer
+
+# Encoder
+input_img = layers.Input(shape=(input_dim,))
+encoded = layers.Dense(256, activation='relu')(input_img)
+encoded = layers.Dense(encoding_dim, activation='relu')(encoded)
+
+# Decoder
+decoded = layers.Dense(256, activation='relu')(encoded)
+decoded = layers.Dense(input_dim, activation='sigmoid')(decoded)  # Use sigmoid since we normalized input between 0 and 1.
+
+# Autoencoder Model
+autoencoder = keras.Model(input_img, decoded)
+
+# Compile the model
+autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
+
+# Train the model
+autoencoder.fit(x_train, x_train,
+                epochs=10,
+                batch_size=128,
+                shuffle=True,
+                validation_data=(x_test, x_test))
+
+# Visualize some results after training
+decoded_imgs = autoencoder.predict(x_test)
+
+n = 8  # Number of digits to display
+plt.figure(figsize=(9,4))
+for i in range(n):
+    # Display original images on top row 
+    ax = plt.subplot(2,n,i+1)
+    plt.imshow(x_test[i].reshape(28, 28), cmap='gray')
+    ax.axis('off')
+
+    # Display reconstructed images on bottom row 
+    ax = plt.subplot(2,n,i+n+1)
+    plt.imshow(decoded_imgs[i].reshape(28, 28), cmap='gray')
+    ax.axis('off')
+
+plt.show()
+
+'''
+### Explanation:
+
+- **Data Loading**: The MNIST dataset is loaded and normalized to a range of [0, 1]. Each image is reshaped into a flat vector.
+- **Model Definition**: An autoencoder architecture is defined with an encoder that compresses the input and a decoder that reconstructs it back to its original form.
+- **Training**: The model is trained using binary crossentropy as the loss function over several epochs.
+- **Visualization**: After training completes, it visualizes original images alongside their reconstructions.
+'''

doc/src/week8/programs/AEpytorch.py

@@ -0,0 +1,96 @@
+### Autoencoder Implementation in PyTorch
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+import matplotlib.pyplot as plt
+
+# Hyperparameters
+batch_size = 128
+learning_rate = 0.001
+num_epochs = 10
+
+# Transform to normalize the data
+transform = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,))
+])
+
+# Load MNIST dataset
+train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
+train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
+
+# Define the Autoencoder Model
+class Autoencoder(nn.Module):
+    def __init__(self):
+        super(Autoencoder, self).__init__()
+        # Encoder layers
+        self.encoder = nn.Sequential(
+            nn.Linear(28 * 28, 256),
+            nn.ReLU(True),
+            nn.Linear(256, 64),
+            nn.ReLU(True)
+        )
+        # Decoder layers
+        self.decoder = nn.Sequential(
+            nn.Linear(64, 256),
+            nn.ReLU(True),
+            nn.Linear(256, 28 * 28),
+            nn.Tanh()   # Use Tanh since we normalized input between -1 and 1.
+        )
+
+    def forward(self, x):
+        x = x.view(-1, 28 * 28)  # Flatten the image tensor into vectors.
+        encoded = self.encoder(x)
+        decoded = self.decoder(encoded)
+        return decoded.view(-1, 1, 28, 28)   # Reshape back to original image dimensions.
+
+# Initialize model, loss function and optimizer
+model = Autoencoder()
+criterion = nn.MSELoss()
+optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+
+# Training Loop
+for epoch in range(num_epochs):
+    for data in train_loader:
+        img, _ = data
+        
+        # Forward pass 
+        output = model(img)
+        
+        # Compute loss 
+        loss = criterion(output, img)
+        
+        # Backward pass and optimization 
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+    print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')
+
+# Visualize some results after training
+with torch.no_grad():
+    sample_data = next(iter(train_loader))[0]
+    reconstructed_data = model(sample_data)
+
+plt.figure(figsize=(9,4))
+for i in range(8):
+    ax = plt.subplot(2,8,i+1)
+    plt.imshow(sample_data[i][0], cmap='gray')
+    ax.axis('off')
+
+    ax = plt.subplot(2,8,i+9)
+    plt.imshow(reconstructed_data[i][0], cmap='gray')
+    ax.axis('off')
+
+plt.show()
+'''
+### Explanation:
+
+- **Data Loading**: The MNIST dataset is loaded with normalization applied.
+- **Model Definition**: An `Autoencoder` class defines both encoder and decoder networks.
+- **Training Loop**: The network is trained over several epochs using Mean Squared Error (MSE) as the loss function.
+- **Visualization**: After training completes, it visualizes original images alongside their reconstructions.
+'''

doc/src/week8/programs/AEpytorch.py~

@@ -0,0 +1,99 @@
+Certainly! Below is a simple implementation of an autoencoder using PyTorch for the MNIST dataset. This example includes data loading, model definition, training, and evaluation.
+
+### Autoencoder Implementation in PyTorch
+
+```python
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+import matplotlib.pyplot as plt
+
+# Hyperparameters
+batch_size = 128
+learning_rate = 0.001
+num_epochs = 10
+
+# Transform to normalize the data
+transform = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Normalize((0.5,), (0.5,))
+])
+
+# Load MNIST dataset
+train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
+train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
+
+# Define the Autoencoder Model
+class Autoencoder(nn.Module):
+    def __init__(self):
+        super(Autoencoder, self).__init__()
+        # Encoder layers
+        self.encoder = nn.Sequential(
+            nn.Linear(28 * 28, 256),
+            nn.ReLU(True),
+            nn.Linear(256, 64),
+            nn.ReLU(True)
+        )
+        # Decoder layers
+        self.decoder = nn.Sequential(
+            nn.Linear(64, 256),
+            nn.ReLU(True),
+            nn.Linear(256, 28 * 28),
+            nn.Tanh()   # Use Tanh since we normalized input between -1 and 1.
+        )
+
+    def forward(self, x):
+        x = x.view(-1, 28 * 28)  # Flatten the image tensor into vectors.
+        encoded = self.encoder(x)
+        decoded = self.decoder(encoded)
+        return decoded.view(-1, 1, 28, 28)   # Reshape back to original image dimensions.
+
+# Initialize model, loss function and optimizer
+model = Autoencoder()
+criterion = nn.MSELoss()
+optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+
+# Training Loop
+for epoch in range(num_epochs):
+    for data in train_loader:
+        img, _ = data
+        
+        # Forward pass 
+        output = model(img)
+        
+        # Compute loss 
+        loss = criterion(output, img)
+        
+        # Backward pass and optimization 
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+    print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')
+
+# Visualize some results after training
+with torch.no_grad():
+    sample_data = next(iter(train_loader))[0]
+    reconstructed_data = model(sample_data)
+
+plt.figure(figsize=(9,4))
+for i in range(8):
+    ax = plt.subplot(2,8,i+1)
+    plt.imshow(sample_data[i][0], cmap='gray')
+    ax.axis('off')
+
+    ax = plt.subplot(2,8,i+9)
+    plt.imshow(reconstructed_data[i][0], cmap='gray')
+    ax.axis('off')
+
+plt.show()
+'''
+### Explanation:
+
+- **Data Loading**: The MNIST dataset is loaded with normalization applied.
+- **Model Definition**: An `Autoencoder` class defines both encoder and decoder networks.
+- **Training Loop**: The network is trained over several epochs using Mean Squared Error (MSE) as the loss function.
+- **Visualization**: After training completes, it visualizes original images alongside their reconstructions.
+'''