pyRBM/cifar_test_sub_image.ipynb

In [2]:

from PIL import Image
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
from rbm.model import Model
from rbm.entity import Entity, EntityParams, TrainingParams
from rbm.matrix import Mat, np, rms_error_accu, sample_gaussian
from rbm.torch import Optimizer
from rbm.image import SubImage, normalize
import math
import random

In [3]:

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))                            
])                              

In [4]:

train_data = torchvision.datasets.CIFAR10(root='./data', train=True, transform=transform, download=True)
test_data = torchvision.datasets.CIFAR10(root='./data', train=False, transform=transform, download=True)

train_loader = torch.utils.data.DataLoader(train_data, batch_size=32, shuffle=True, num_workers=2)
test_loader = torch.utils.data.DataLoader(test_data, batch_size=32, shuffle=True, num_workers=2)

In [5]:

print(train_data)

Dataset CIFAR10
    Number of datapoints: 50000
    Root location: ./data
    Split: Train
    StandardTransform
Transform: Compose(
               ToTensor()
               Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
           )

In [6]:

N = 500
n_side = 10
N_VIS = 3072
n_sub = 8
px = 8
py = 8

image, label = train_data[0]
size = len(torch.flatten(image))
train_images = np.zeros(shape=(N, size))
train_images_tensor = torch.Tensor(N, size)
for i in range(N):
    image, label = train_data[i]
    flat_array = torch.flatten(image)
    train_images[i, :] = np.asarray(flat_array.numpy())
    train_images_tensor[i, :] = flat_array
print(image.shape)

torch.Size([3, 32, 32])

In [7]:

image_indices = np.array(random.sample(range(min(N, n_side*n_side)), n_side*n_side))
print(f"train_images.shape:{train_images.shape}")
mean_training_batch = np.reshape(np.repeat(np.mean(train_images, axis=1), N_VIS, axis=0), train_images.shape)
var_training_batch = np.reshape(np.repeat(np.std(train_images, axis=1), N_VIS, axis=0), train_images.shape)
#print(f"mean_training_batch:{mean_training_batch}")
#print(f"var_training_batch:{var_training_batch}")
train_images_norm = (train_images - mean_training_batch) / var_training_batch
sub_generator = SubImage(n_sub,n_sub,px,py)
train_subimages = sub_generator(np.reshape(train_images, (N, 3, 32, 32)), 3)
print(train_subimages.shape)
train_subimages = np.reshape(train_subimages, (train_subimages.shape[0], 3*n_sub*n_sub))
print(train_subimages.shape)

train_images.shape:(500, 3072)
(8000, 3, 8, 8)
(8000, 192)

In [8]:

fig, axes = plt.subplots(n_side, n_side, figsize=(30,30))
index = 0             
for x in range(n_side):
    for y in range(n_side):
        inp = train_subimages[image_indices[index]]
        img = (1+np.reshape(inp, (3, n_sub, n_sub)))/2
        img = img.transpose((1,2,0))
        axes[x,y].imshow(np.asnumpy(img))
        axes[x,y].axis('off')
        index += 1

plt.show()

In [9]:

class TestModel(Model):
    def __init__(self, name: str, work_dir: str = '.'):
        super().__init__(name, work_dir)
        #self.unit1 = Entity((3072, 125), EntityParams(do_gaussian_visible=True, do_gaussian_hidden=True), TrainingParams(learning_rate=0.0001, momentum=0.9, num_epochs=1000, mini_batch_size=0, weight_decay=0.0, l2_lambda=0.0))
        self.unit1 = Entity((3*n_sub*n_sub, 125), EntityParams(do_gaussian_visible=True, do_gaussian_hidden=False), TrainingParams(learning_rate=0.0005, momentum=0.9, num_epochs=1000, mini_batch_size=1000, weight_decay=0.0, l1_lambda=0.02))
    
    def forward(self, x: Mat):
        x = self.unit1.forward(x)
        return x
    
    def backward(self, x: Mat):
        x = self.unit1.reconstruct(x)
        return x

In [14]:

work_dir = "results"
prj_name = "cifar_test"
prj_root = "/home/jens/work/repos/Rbm"

# Create model
model = TestModel(prj_name, "results")

# Init state
model.init(0.01)

# load state
model.load()

# Train
#model.train(normalize(train_subimages))
model.train(train_subimages)

# save state
model.save()

results/cifar_test-0-state.npz loaded successfully!
-------------------------------------------
Entity-192x125: progress              : 0%
Entity-192x125: err_rms              : 0.030379165370610535
Entity-192x125: l2_norm              : 0.4078751956343499
-------------------------------------------
Entity-192x125: progress              : 10%
Entity-192x125: err_rms              : 0.030262160894958236
Entity-192x125: l2_norm              : 0.41355889836481896
-------------------------------------------
Entity-192x125: progress              : 20%
Entity-192x125: err_rms              : 0.029900639244116074
Entity-192x125: l2_norm              : 0.41922849190817446
-------------------------------------------
Entity-192x125: progress              : 30%
Entity-192x125: err_rms              : 0.029633229490245574
Entity-192x125: l2_norm              : 0.4243204163117055
-------------------------------------------
Entity-192x125: progress              : 40%
Entity-192x125: err_rms              : 0.029643144088911992
Entity-192x125: l2_norm              : 0.4296720180619314
-------------------------------------------
Entity-192x125: progress              : 50%
Entity-192x125: err_rms              : 0.029236906256852126
Entity-192x125: l2_norm              : 0.4342366888914084
-------------------------------------------
Entity-192x125: progress              : 60%
Entity-192x125: err_rms              : 0.029083843641787288
Entity-192x125: l2_norm              : 0.4386505626280037
-------------------------------------------
Entity-192x125: progress              : 70%
Entity-192x125: err_rms              : 0.029287222814984724
Entity-192x125: l2_norm              : 0.4427719382112543
-------------------------------------------
Entity-192x125: progress              : 80%
Entity-192x125: err_rms              : 0.02911689718671403
Entity-192x125: l2_norm              : 0.44673204669364625
-------------------------------------------
Entity-192x125: progress              : 90%
Entity-192x125: err_rms              : 0.029132421296822808
Entity-192x125: l2_norm              : 0.45006110022836515
-------------------------------------------
Entity-192x125: progress              : 100%
Entity-192x125: err_rms              : 0.0291709503482291
Entity-192x125: l2_norm              : 0.45335492303832076
-------------------------------------------
Entity-192x125: progress              : 100%
Entity-192x125: err_rms_total              : 0.028712401745574247
Entity-192x125: l2_norm              : 0.4536369206630987
results/cifar_test-0-state.npz saved successfully!

In [15]:

# Plot reconstructions
fig, axes = plt.subplots(n_side, n_side, figsize=(30,30))
index = 0             
for x in range(n_side):
    for y in range(n_side):
        inp = train_subimages[image_indices[index]]
        recon = model.backward(model.forward(inp))
        recon -= np.min(recon)
        recon = recon / np.max(recon)
        img = np.reshape(recon, (3, n_sub, n_sub))
        img = img.transpose((1,2,0))
        axes[x,y].imshow(np.asnumpy(img))
        axes[x,y].axis('off')
        index += 1

plt.show()

In [12]:

# Plot weights
weights = model.unit1.state.w_hv
n, n_hid = weights.shape
weight_indices = np.array(random.sample(range(n_hid), n_side*n_side))
w = np.reshape(weights, (3, n_sub, n_sub, n_hid))
print(w.shape)
fig, axes = plt.subplots(n_side, n_side, figsize=(30,30))

index = 0
for x in range(n_side):
    for y in range(n_side):
        inp = np.asnumpy(w[:,:,:, weight_indices[index]])
        inp -= np.min(inp)
        inp = inp / np.max(inp)
        img = inp.transpose((1,2,0))
        axes[x,y].imshow(np.asnumpy(img))
        axes[x,y].axis('off')
        index += 1

plt.show()

(3, 8, 8, 125)

In [12]:

In [12]:

In [12]: