pytorch_01.html

📑 Pytorch Workout 01

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

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

6

import sys; sys.path.append(spath)

7

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

8

import h5py,urllib,torch,torchvision

9

import torchvision.transforms as tvt,\

10

torchvision.datasets as tvd,torchvision.utils as tvu

11

import sklearn.datasets as skd

12

from torch.utils.data import Dataset as tds

13

from torch.utils.data import DataLoader as tdl

14

from IPython.core.magic import register_line_magic

15

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

16

html('<style>.sagecell_input '+\

17

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

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

---

Messages

Image Data

xxxxxxxxxx

 

1

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

2

     'OlgaBelitskaya/data_kitchen/main/'

3

zf='Flowers128.h5'; input_file=urllib.request.urlopen(path+zf)

4

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

5

output_file.close(); input_file.close()

6

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

7

    keys=list(f.keys())

8

    pretty_print(html(

9

        '<p style="color:darkorange">file keys: '+\

10

        ', '.join(keys)+'</p>'))

11

    images=np.array(f[keys[0]]); labels=np.array(f[keys[1]])

12

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

13

    f.close()

14

N=labels.shape[0]; n=int(.1*N); shuffle_ids=np.arange(N)

15

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

16

images=images[shuffle_ids]; labels=labels[shuffle_ids]

17

x_test,x_valid,x_train=images[:n],images[n:2*n],images[2*n:]

18

y_test,y_valid,y_train=labels[:n],labels[n:2*n],labels[2*n:]

19

df=pd.DataFrame(

20

    [[x_train.shape,x_valid.shape,x_test.shape],

21

     [x_train.dtype,x_valid.dtype,x_test.dtype],

22

     [y_train.shape,y_valid.shape,y_test.shape],

23

     [y_train.dtype,y_valid.dtype,y_test.dtype]],

24

    columns=['train','valid','test'],

25

    index=['image shape','image type',

26

           'label shape','label type'])

27

fig=pl.figure(figsize=(6,4)); n=randint(1,100)

28

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

29

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

30

    ax.set_title('$\\mathscr{'+names[labels[i]]+'}$',

31

                 color='slategray',

32

                 fontdict={'fontsize':'small'})

33

    ax.imshow((images[i]))

34

pl.tight_layout(); pl.show(); display(df)

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

---

Messages

Data Loaders

xxxxxxxxxx

 

1

x_train=np.clip(x_train*255,0,255).astype(np.uint8)

2

x_test=np.clip(x_test*255,0,255).astype(np.uint8)

3

x_valid=np.clip(x_valid*255,0,255).astype(np.uint8)

4

class FlowerData(tds):

5

    def __init__(self,images,labels,transform=None):

6

        self.images=images

7

        self.labels=labels

8

        self.transform=transform        

9

    def __getitem__(self,index):

10

        x=self.images[index]

11

        y=self.labels[index]        

12

        if self.transform: x=self.transform(x)           

13

        return x,y   

14

    def __len__(self):

15

        return len(self.labels)

16

batch_size=int(16); num_workers=int(4); img_size=int(32)

17

trans=tvt.Compose(

18

    [tvt.ToPILImage(),

19

     tvt.Resize((img_size,img_size)),tvt.ToTensor()])

20

train=FlowerData(images=x_train,labels=y_train,transform=trans)

21

test=FlowerData(images=x_test,labels=y_test,transform=trans)

22

valid=FlowerData(images=x_valid,labels=y_valid,transform=trans)

23

dataloaders={'train':tdl(dataset=train,batch_size=batch_size,

24

                         shuffle=True,num_workers=num_workers),

25

             'test':tdl(dataset=test,batch_size=batch_size,

26

                        shuffle=True,num_workers=num_workers),

27

             'valid':tdl(dataset=valid,batch_size=batch_size,

28

                         shuffle=True,num_workers=num_workers)}

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

---

Messages

xxxxxxxxxx

 

1

@register_line_magic

2

def display_examples(data):

3

    for images,labels in dataloaders[data]:  

4

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

5

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

6

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

7

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

8

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

9

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

10

            ax.set_title('$\\mathscr{'+names[labels[i].item()]+'}$',

11

                         fontsize=8,color='slategray')

12

            ax.imshow(np.transpose(images[i],(1,2,0)))

13

        pl.tight_layout(); pl.show()

14

        break

15

%display_examples valid

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

---

Messages

Model Building

xxxxxxxxxx

 

1

from torchvision import models

2

import torch.nn.functional as tnnf

3

import torch.nn as tnn

4

num_classes=len(names)

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

---

Messages

xxxxxxxxxx

 

1

class FilterResponseNorm(tnn.Module):

2

    def __init__(self,num_features,eps=float(1e-6)):

3

        super(FilterResponseNorm,self).__init__()        

4

        self.register_parameter('beta',\

5

        tnn.Parameter(torch.empty(

6

            [int(1),num_features,int(1),int(1)]).normal_()))

7

        self.register_parameter('gamma',\

8

        tnn.Parameter(torch.empty(

9

            [int(1),num_features,int(1),int(1)]).normal_()))      

10

        self.register_parameter('tau',\

11

        tnn.Parameter(torch.empty(

12

            [int(1),num_features,int(1),int(1)]).normal_()))     

13

        self.eps=torch.Tensor([eps])

14

    def forward(self,x):

15

        n,c,h,w=x.size()        

16

        self.eps=self.eps.to(self.tau.device)

17

        nu2=torch.mean(x.pow(int(2)),(int(2),int(3)),keepdims=True)

18

        x=x*torch.rsqrt(nu2+torch.abs(self.eps))

19

        return torch.max(self.gamma*x+self.beta,self.tau)

20

def convfrn(x,y,k,s,p):

21

    return tnn.Sequential(

22

        tnn.Conv2d(x,y,kernel_size=k,stride=s,padding=p),

23

                   FilterResponseNorm(y))

24

class FRN_NNinNN(tnn.Module):

25

    def __init__(self,num_classes):

26

        super(FRN_NNinNN,self).__init__()

27

        self.num_classes=num_classes

28

        self.classifier=tnn.Sequential(

29

            convfrn(int(3),int(192),int(5),int(1),int(2)),

30

            convfrn(int(192),int(160),int(1),int(1),int(0)),

31

            convfrn(int(160),int(96),int(1),int(1),int(0)),

32

            tnn.MaxPool2d(

33

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

34

            tnn.Dropout(float(.5)),

35

            convfrn(int(96),int(192),int(5),int(1),int(2)),

36

            convfrn(int(192),int(192),int(1),int(1),int(0)),

37

            convfrn(int(192),int(192),int(1),int(1),int(0)),

38

            tnn.AvgPool2d(

39

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

40

            tnn.Dropout(float(.5)),

41

            convfrn(int(192),int(192),int(3),int(1),int(1)),

42

            convfrn(int(192),int(192),int(1),int(1),int(0)),

43

            tnn.Conv2d(int(192),self.num_classes,kernel_size=int(1),

44

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

45

            tnn.ReLU(),

46

            tnn.AvgPool2d(

47

                kernel_size=int(8),stride=int(1),padding=int(0)))

48

    def forward(self,x):

49

        x=self.classifier(x)

50

        logits=x.view(x.size(int(0)),self.num_classes)

51

        probs=torch.softmax(logits,dim=int(1))

52

        return logits,probs

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

---

Messages

xxxxxxxxxx

 

1

random_seed=int(12); learning_rate=float(.00005)

2

torch.manual_seed(random_seed)

3

tmodel=FRN_NNinNN(num_classes)

4

tmodel=tmodel.to(dev)

5

optimizer=torch.optim.Adam(

6

    tmodel.parameters(),lr=learning_rate)

7

def model_acc(model,data_loader):

8

    correct_preds,num_examples=int(0),int(0)  

9

    for features,targets in data_loader:

10

        features=features.to(dev)

11

        targets=targets.to(dev).long()

12

        logits=model(features)

13

        _,pred_labels=torch.max(logits[int(0)],int(1))

14

        num_examples+=targets.size(int(0))

15

        correct_preds+=(pred_labels==targets).sum()        

16

    return correct_preds.float()/num_examples*int(100)

17

def epoch_loss(model,data_loader):

18

    model.eval()

19

    curr_loss,num_examples=float(0.),int(0)

20

    with torch.no_grad():

21

        for features,targets in data_loader:

22

            features=features.to(dev)

23

            targets=targets.to(dev).long()

24

            logits=model(features)

25

            loss=tnnf.cross_entropy(

26

                logits[int(0)],targets,reduction='sum')

27

            num_examples+=targets.size(int(0))

28

            curr_loss+=loss

29

        return curr_loss/num_examples

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

---

Messages

Model Training

xxxxxxxxxx

 

1

@register_line_magic

2

def train_run(epochs):

3

    epochs=int(epochs)

4

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

5

    str2='train acc/loss: %.2f%%/%.2f valid acc/loss: %.2f%%/%.2f'

6

    for epoch in range(epochs):

7

        tmodel.train()

8

        for batch_ids,(features,targets) \

9

        in enumerate(dataloaders['train']):        

10

            features=features.to(dev)

11

            targets=targets.to(dev).long()

12

            logits=tmodel(features)

13

            cost=tnnf.cross_entropy(logits[int(0)],targets)

14

            optimizer.zero_grad(); cost.backward()

15

            optimizer.step()

16

            if not batch_ids%int(10):

17

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

18

                             len(dataloaders['train']),cost))

19

        tmodel.eval()

20

        with torch.set_grad_enabled(False):

21

            print('Epoch: %03d/%03d'%(epoch+int(1),epochs))

22

            print(str2%\

23

                  (model_acc(tmodel,dataloaders['train']),

24

                   epoch_loss(tmodel,dataloaders['train']),

25

                   model_acc(tmodel,dataloaders['valid']),

26

                   epoch_loss(tmodel,dataloaders['valid'])))

27

%train_run 2

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

---

Messages

Model Evaluation

xxxxxxxxxx

 

1

tmodel.eval()

2

with torch.set_grad_enabled(False):

3

    print('test acc: %.2f%%'%(

4

        model_acc(tmodel,dataloaders['test'])))

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

---

Messages