pytorch_02.html

📑 Pytorch Workout 02

Code Modules

xxxxxxxxxx

 

1

#!python3 -m pip install torch==1.8.0 \

2

#--user --quiet --no-warn-script-location

3

!python3 -m pip install torchvision==0.9.0 \

4

--user --quiet --no-warn-script-location

5

#!python3 -m pip install tensorflow==2.6.0 \

6

#--user --quiet --no-warn-script-location

7

path='/home/sc_work/.sage/local/lib/python3.9/site-packages'

8

import sys,warnings; sys.path.append(path)

9

warnings.filterwarnings('ignore')

10

import numpy as np,pandas as pd,pylab as pl,tensorflow as tf

11

import zipfile,h5py,urllib,torch,torchvision

12

import torchvision.transforms as tvt,\

13

torchvision.datasets as tvd,torchvision.utils as tvu

14

from torchvision import models

15

import torch.nn.functional as tnnf,torch.nn as tnn

16

from torch.utils.data import Dataset as tds

17

from torch.utils.data import DataLoader as tdl

18

from IPython.core.magic import register_line_magic

19

dev=torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

20

html('<style>.sagecell_input '+\

21

     '{text-shadow:4px 4px 4px #aaa;}</style>')

Language: Sage Gap GP HTML Macaulay2 Maxima Octave Python R Singular

---

Messages

Data Loading

xxxxxxxxxx

 

1

names=[['lowercase','uppercase'],

2

       [s for s in u'абвгдеёжзийклмнопрстуфхцчшщъыьэюя'],

3

       ['single-colored paper','striped paper',

4

        'squared paper','graph paper']]

5

path='https://raw.githubusercontent.com/'+\

6

     'OlgaBelitskaya/data/main/zip_letters/'

7

def file_name(lower_upper,letter,background,names=names):

8

    file_pre='%02d_'%names[0].index(lower_upper)

9

    file_pre+='%02d_'%names[1].index(letter)

10

    file_pre+='%02d'%names[2].index(background)

11

    return file_pre+'.h5'

12

file_names=[file_name(n0,n1,n2) for n2 in names[2] 

13

            for n1 in names[1] for n0 in names[0]]

14

file_names=[file_names[i] for i in [0,2..18]]; file_names

Language: Sage Gap GP HTML Macaulay2 Maxima Octave Python R Singular

---

Messages

xxxxxxxxxx

 

1

images,nlabels,labels=[],[],[]

2

for h5f in file_names:

3

    input_file=urllib.request.urlopen(path+h5f)

4

    output_file=open(h5f,'wb'); output_file.write(input_file.read())

5

    output_file.close(); input_file.close()

6

    with h5py.File(h5f,'r') as f:

7

        keys=list(f.keys()); nums=f[keys[0]].shape[0]

8

        print('file name: %s; '%h5f+'number of images: %d'%nums)

9

        images.append(np.array(f[keys[0]],dtype='float32'))

10

        nlabels=[el.decode('utf-8') for el in f[keys[1]]]

11

        labels.append(np.array(

12

            nums*[[names[i].index(nlabels[i]) 

13

                   for i in range(3)]],dtype='int32'))

14

        f.close(); os.remove(h5f)

15

images=np.concatenate(images,axis=0)

16

labels=np.concatenate(labels,axis=0)

17

images.shape,images.dtype,nlabels,labels.shape,labels.dtype

Language: Sage Gap GP HTML Macaulay2 Maxima Octave Python R Singular

---

Messages

xxxxxxxxxx

 

1

shuffle_ids=np.arange(images.shape[0])

2

np.random.RandomState(1234).shuffle(shuffle_ids)

3

images=images[shuffle_ids]

4

labels=labels[shuffle_ids]

5

def display_images(n_images,cols,images,labels):

6

    rows=n_images//cols    

7

    pl.figure(figsize=(cols,rows))

8

    for i in range(n_images):

9

        pl.subplot(rows,cols,i+1); pl.imshow(images[i])

10

        pl.title('$\\mathbb{'+str(labels[i])+'}$')

11

        pl.xticks([]); pl.yticks([])

12

    pl.tight_layout(); pl.show()

13

display_images(10,5,images,labels)

Language: Sage Gap GP HTML Macaulay2 Maxima Octave Python R Singular

---

Messages

Data Processing

xxxxxxxxxx

 

1

img_size=int(28); N=labels.shape[0]; n=int(float(.2)*N)

2

images=tf.image.resize(images,[img_size,img_size])

3

images=x=(np.dot(images.numpy(),[.299,.587,.114]))\

4

.reshape(-int(1),int(1),img_size,img_size)

5

x_test,x_train=images[:n],images[n:]

6

y_test,y_train=labels[:,1][:n],labels[:,1][n:]

7

random_seed=int(23); batch_size=int(128)

8

class TData(tds):

9

    def __init__(self,x,y):   

10

        self.x=torch.tensor(x,dtype=torch.float32)

11

        self.y=torch.tensor(y,dtype=torch.int32)

12

    def __getitem__(self,index):

13

        img,lbl=self.x[index],self.y[index]

14

        return img,lbl

15

    def __len__(self):

16

        return self.y.shape[int(0)]

17

train=TData(x_train,y_train); test=TData(x_test,y_test)

18

train_loader=tdl(

19

    dataset=train,shuffle=True,batch_size=batch_size)

20

test_loader=tdl(

21

    dataset=test,shuffle=False,batch_size=batch_size)

Language: Sage Gap GP HTML Macaulay2 Maxima Octave Python R Singular

---

Messages

xxxxxxxxxx

 

1

@register_line_magic

2

def display_examples(n):

3

    if n=='1': data_loader=train_loader

4

    if n=='2': data_loader=test_loader

5

    for images,labels in data_loader:  

6

        print('image dimensions: %s'%str(images.shape))

7

        print('label dimensions: %s'%str(labels.shape))

8

        n=np.random.randint(1,50)

9

        fig=pl.figure(figsize=(6,2))

10

        for i in range(n,n+7):

11

            ax=fig.add_subplot(1,7,i-n+1,xticks=[],yticks=[])

12

            ax.set_title('$\\mathbb{'+str(labels[i].item())+'}$')

13

            ax.imshow((images[i]).reshape(img_size,img_size),

14

                      cmap=pl.cm.bone)

15

        pl.tight_layout(); pl.show(); break

16

%display_examples 2

Language: Sage Gap GP HTML Macaulay2 Maxima Octave Python R Singular

---

Messages

An Example of Convolutional Conditional Variational Autoencoder

xxxxxxxxxx

 

1

ch1,ch2,ch3=int(16),int(48),int(144)

2

def to_onehot(labels,num_classes,device):

3

    labels_ohe=torch.zeros(

4

        labels.size()[int(0)],num_classes).to(device)

5

    labels_ohe.scatter_(

6

        int(1),labels.view(-int(1),int(1)),int(1))

7

    return labels_ohe

8

class CondVarAE(tnn.Module):

9

    def __init__(self,num_features,num_latent,num_classes):

10

        super(CondVarAE,self).__init__()

11

        self.num_classes=num_classes

12

        # ENCODER

13

        self.conv_en1=tnn.Conv2d(

14

            in_channels=1+self.num_classes,out_channels=ch1,

15

            kernel_size=(int(6),int(6)),

16

            stride=(int(2),int(2)),padding=int(0))

17

        self.conv_en2=tnn.Conv2d(

18

            in_channels=ch1,out_channels=ch2,

19

            kernel_size=(int(4),int(4)),

20

            stride=(int(2),int(2)),padding=int(0))

21

        self.conv_en3=tnn.Conv2d(

22

            in_channels=ch2,out_channels=ch3,

23

            kernel_size=(int(2),int(2)),

24

            stride=(int(2),int(2)),padding=int(0))

25

        self.z_mean=tnn.Linear(ch3*int(2)*int(2),num_latent)

26

        self.z_log_var=\

27

        tnn.Linear(ch3*int(2)*int(2),num_latent)

28

        # DECODER

29

        self.linear_de1=tnn.Linear(

30

            num_latent+self.num_classes,ch3*int(2)*int(2))

31

        self.deconv_de1=tnn.ConvTranspose2d(

32

            in_channels=ch3,out_channels=ch2,

33

            kernel_size=(int(2),int(2)),

34

            stride=(int(2),int(2)),padding=int(0))              

35

        self.deconv_de2=tnn.ConvTranspose2d(

36

            in_channels=ch2,out_channels=ch1,

37

            kernel_size=(int(4),int(4)),

38

            stride=(int(3),int(3)),padding=int(1))

39

        self.deconv_de3=tnn.ConvTranspose2d(

40

            in_channels=ch1,out_channels=1,

41

            kernel_size=(int(6),int(6)),

42

            stride=(int(3),int(3)),padding=int(4))

43

    def reparameterize(self,z_mu,z_log_var):

44

        eps=torch.randn(

45

            z_mu.size(int(0)),z_mu.size(int(1))).to(dev)

46

        return z_mu+eps*torch.exp(z_log_var/float(2.))

47

    def encoder(self,features,targets):

48

        onehot_targets=to_onehot(targets,self.num_classes,dev)

49

        onehot_targets=onehot_targets.view(

50

            -int(1),self.num_classes,int(1),int(1))

51

        ones=torch.ones(

52

            features.size()[int(0)],self.num_classes,

53

            features.size()[int(2)],features.size()[int(3)],

54

            dtype=features.dtype).to(dev)

55

        ones=ones*onehot_targets

56

        x=torch.cat((features,ones),dim=int(1)) 

57

        x=self.conv_en1(x); x=tnnf.leaky_relu(x) 

58

        x=self.conv_en2(x); x=tnnf.leaky_relu(x)

59

        x=self.conv_en3(x); x=tnnf.leaky_relu(x)

60

        z_mean=self.z_mean(

61

            x.view(-int(1),ch3*int(2)*int(2)))

62

        z_log_var=self.z_log_var(

63

            x.view(-int(1),ch3*int(2)*int(2)))

64

        encoded=self.reparameterize(z_mean,z_log_var)

65

        return z_mean,z_log_var,encoded  

66

    def decoder(self,encoded,targets):

67

        onehot_targets=\

68

        to_onehot(targets,self.num_classes,dev)

69

        encoded=torch.cat(

70

            (encoded,onehot_targets),dim=int(1))

71

        x=self.linear_de1(encoded)

72

        x=x.view(-int(1),ch3,int(2),int(2)) 

73

        x=self.deconv_de1(x); x=tnnf.leaky_relu(x)

74

        x=self.deconv_de2(x); x=tnnf.leaky_relu(x)

75

        x=self.deconv_de3(x); x=tnnf.leaky_relu(x)

76

        decoded=torch.sigmoid(x)

77

        return decoded

78

    def forward(self,features,targets):

79

        z_mean,z_log_var,encoded=self.encoder(features,targets)

80

        decoded=self.decoder(encoded,targets)

81

        return z_mean,z_log_var,encoded,decoded

Language: Sage Gap GP HTML Macaulay2 Maxima Octave Python R Singular

---

Messages

xxxxxxxxxx

 

1

torch.manual_seed(random_seed)

2

learning_rate=float(.0015); num_latent=int(121)

3

num_classes=len(set(y_train))

4

model=CondVarAE(

5

    num_features=img_size**int(2),

6

    num_latent=num_latent,num_classes=num_classes)

7

model=model.to(dev)

8

optimizer=torch.optim.Adam(

9

    model.parameters(),lr=learning_rate)

Language: Sage Gap GP HTML Macaulay2 Maxima Octave Python R Singular

---

Messages

Model Training

xxxxxxxxxx

 

1

epochs=int(10)

2

for epoch in range(epochs):

3

    str1='Epoch: %03d/%03d | Batch: %03d/%03d | Cost: %.4f'

4

    for batch_ids,(features,targets) in enumerate(train_loader):

5

        features=features.to(dev); targets=targets.to(dev)

6

        z_mean,z_log_var,encoded,decoded=\

7

        model(features,targets.long())

8

        kl_divergence=\

9

        (float(.5)*(z_mean**int(2)+\

10

         torch.exp(z_log_var)-z_log_var-int(1))).sum()

11

        pixelwise_bce=tnnf.binary_cross_entropy(

12

            decoded,features,reduction='sum')

13

        cost=kl_divergence+pixelwise_bce

14

        optimizer.zero_grad()

15

        cost.backward(); optimizer.step()

16

        if not batch_ids%int(50):

17

            print (str1%(epoch+int(1),epochs,batch_ids,

18

                         len(train_loader),cost))

Language: Sage Gap GP HTML Macaulay2 Maxima Octave Python R Singular

---

Messages

Reconstruction

xxxxxxxxxx

 

1

num_images=int(5)

2

fig,axes=pl.subplots(

3

    nrows=2,ncols=num_images,sharex=True,

4

    sharey=True,figsize=(6,4))

5

original_images=features[:num_images]

6

decoded_images=decoded[:num_images]

7

for i in range(num_images):

8

    for ax,img in zip(axes,[original_images,decoded_images]):

9

        ax[i].imshow(img[i].detach().to(torch.device('cpu'))\

10

        .reshape((img_size,img_size)),cmap='bone')

11

pl.tight_layout(); pl.show()

Language: Sage Gap GP HTML Macaulay2 Maxima Octave Python R Singular

---

Messages

Generating

xxxxxxxxxx

 

1

@register_line_magic

2

def display_gen(l):

3

    l=int(l); num_images=int(5)

4

    labels=torch.tensor([int(l)]*num_images).to(dev)

5

    latent_features=torch.randn(num_images,num_latent).to(dev)

6

    generated_images=model.decoder(latent_features,labels)

7

    decoded_images=generated_images[:num_images]

8

    fig,axes=pl.subplots(nrows=1,ncols=num_images,

9

                         figsize=(6,2),sharey=True)

10

    for ax,img in zip(axes,decoded_images):

11

        ax.imshow(img.detach().to(torch.device('cpu'))\

12

                  .reshape((img_size,img_size)),cmap='bone')

13

    pl.tight_layout(); pl.show()

14

%display_gen 0

15

%display_gen 2

Language: Sage Gap GP HTML Macaulay2 Maxima Octave Python R Singular

---

Messages