📑 Processing & Classification of Tomato Cultivars` Images

🌐   DL_PP6_0_SMC.html

📑 Deep Learning. Practice Project 6_0:
Processing & Classification of Tomato Cultivars` Images

✒️ Code Modules, Helpful Functions, & Settings

xxxxxxxxxx

 

1

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

2

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

3

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

4

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

5

!python3 -m pip install torchvision==0.9.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 os,h5py,urllib,pandas as pd,numpy as np

11

from sklearn.ensemble import RandomForestClassifier as sRFC

12

from sklearn.metrics import accuracy_score,hamming_loss

13

from sklearn.metrics import classification_report

14

import torch,tensorflow as tf,pylab as pl

15

import tensorflow.keras.layers as tkl

16

import tensorflow.keras.callbacks as tkc

17

from torch.utils.data import DataLoader as tdl

18

from torch.utils.data import Dataset as tds

19

from torchvision import transforms,utils,models

20

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

21

dev=torch.device(

22

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

23

from IPython.core.magic import register_line_magic

24

from IPython.display import HTML

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

---

Messages

✒️ Data Loading

xxxxxxxxxx

 

1

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

2

          'OlgaBelitskaya/data_kitchen/main/'

3

file_name='TomatoCultivars160.h5'; img_size=int(64)

4

def get_file(file_path,file_name):

5

    input_file=urllib.request.urlopen(file_path+file_name)

6

    output_file=open(file_name,'wb')

7

    output_file.write(input_file.read())

8

    output_file.close(); input_file.close()

9

get_file(file_path,file_name)

10

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

11

    keys=list(f.keys())

12

    pretty_print(html(

13

        '<p>'+10*'&nbsp;'+'file keys: '+', '.join(keys)+'</p>'))

14

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

15

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

16

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

17

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

18

    f.close()

19

@interact(layout=dict(top=[['get_img_size']]))

20

def _get_data_resize(get_img_size=slider([64,60,..,32],default=32)):

21

    global img_size,images

22

    img_size=int(get_img_size)

23

    pretty_print(html('<p>image size: %d<'%img_size+'/p>'))

24

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

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

---

Messages

✒️ Data Processing

xxxxxxxxxx

 

1

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

2

num_classes=len(names) 

3

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

4

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

5

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

6

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

7

df=pd.DataFrame(

8

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

9

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

10

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

11

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

12

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

13

    index=['image shape','image type','label shape','label type'])

14

def display_imgs(images,labels,names,n=12):

15

    fig=pl.figure(figsize=(10,3))

16

    for i in range(0,n):

17

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

18

        ax.set_title(

19

            names[labels[i]],color='slategray',

20

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

21

        ax.imshow((images[i]))

22

    pl.tight_layout(); pl.show()

23

display_imgs(images,labels,names); display(df)

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

---

Messages

xxxxxxxxxx

 

1

class TData(tds):

2

    def __init__(self,x,y):   

3

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

4

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

5

    def __getitem__(self,index):

6

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

7

        return img,lbl

8

    def __len__(self):

9

        return self.y.shape[0]

10

batch_size2=int(16)

11

n_train=batch_size2*(x_train.shape[0]//batch_size2)

12

x_train2=np.transpose(x_train,(0,3,1,2))[:n_train]

13

print(x_train2.mean(),x_train2.std())

14

n_valid=batch_size2*(x_valid.shape[0]//batch_size2)

15

x_valid2=np.transpose(x_valid,(0,3,1,2))[:n_valid]

16

n_test=batch_size2*(x_test.shape[0]//batch_size2)

17

x_test2=np.transpose(x_test,(0,3,1,2))[:n_test]

18

random_seed=23

19

train2=TData(x_train2,y_train[:n_train])

20

valid2=TData(x_valid2,y_valid[:n_valid])

21

test2=TData(x_test2,y_test[:n_test])

22

dataloaders={'train':tdl(dataset=train2,shuffle=True,

23

                         batch_size=batch_size2), 

24

             'valid':tdl(dataset=valid2,shuffle=True,

25

                         batch_size=batch_size2),

26

             'test':tdl(dataset=test2,shuffle=True,

27

                        batch_size=batch_size2)}

28

del train2,valid2,test2

29

@register_line_magic

30

def display_data_imgs(data):

31

    global names

32

    for images,labels in dataloaders[data]:  

33

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

34

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

35

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

36

                for i in range(len(images))]

37

        display_imgs(images,labels,names,int(8))

38

        break

39

%display_data_imgs valid

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

---

Messages

✒️ Sklearn

xxxxxxxxxx

 

1

def classifier_fit_score(classifier,x_train,x_test,y_train,y_test):

2

    classifier.fit(x_train,y_train)     

3

    y_clf_train=classifier.predict(x_train)

4

    y_clf_test=classifier.predict(x_test)        

5

    acc_clf_train=round(accuracy_score(y_train,y_clf_train),int(4))

6

    acc_clf_test=round(accuracy_score(y_test,y_clf_test),int(4))

7

    loss_clf_train=round(hamming_loss(y_train,y_clf_train),int(4))

8

    loss_clf_test=round(hamming_loss(y_test,y_clf_test),int(4))  

9

    return [y_clf_train,y_clf_test,acc_clf_train,acc_clf_test,

10

            loss_clf_train,loss_clf_test]

11

[y_srfc_train,y_srfc_test,acc_srfc_train,

12

 acc_srfc_test,loss_srfc_train,loss_srfc_test]=\

13

classifier_fit_score(

14

    sRFC(),x_train.reshape(-int(1),int(3)*img_size**2),

15

    x_test.reshape(-int(1),int(3)*img_size**2),y_train,y_test)

16

print(classification_report(y_test,y_srfc_test))

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

---

Messages

xxxxxxxxxx

 

1

def plot_predict(y_predict,label_predict,t=30,fig_size=6):

2

    pl.figure(figsize=(fig_size,fig_size//4)); x=range(t)

3

    pl.scatter(x,y_test[:t],marker='*',s=100,

4

               color='slategray',label='Real data')

5

    pl.scatter(x,y_predict[:t],marker='v',s=50,

6

               color='#348ABD',label=label_predict)

7

    pl.xlabel('Observations'); pl.ylabel('Targets') 

8

    pl.title('Classifiers. Test Results',color='slategray',

9

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

10

    pl.legend(loc=2,fontsize=10)

11

    pl.tight_layout; pl.show()

12

plot_predict(y_srfc_test,'Random Forest')

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

---

Messages

✒️ Keras

xxxxxxxxxx

 

1

def kmodel(leaky_alpha,num_classes,img_size):

2

    model=tf.keras.Sequential()

3

    model.add(tkl.Conv2D(int(32),(int(5),int(5)),padding='same', 

4

                         input_shape=(img_size,img_size,int(3))))

5

    model.add(tkl.LeakyReLU(alpha=leaky_alpha))    

6

    model.add(tkl.MaxPooling2D(pool_size=(int(2),int(2))))

7

    model.add(tkl.Dropout(float(.25)))

8

    model.add(tkl.Conv2D(int(96),(int(5),int(5))))

9

    model.add(tkl.LeakyReLU(alpha=leaky_alpha))    

10

    model.add(tkl.MaxPooling2D(pool_size=(int(2),int(2))))

11

    model.add(tkl.Dropout(float(.25)))   

12

    model.add(tkl.GlobalMaxPooling2D())     

13

    model.add(tkl.Dense(int(512)))

14

    model.add(tkl.LeakyReLU(alpha=leaky_alpha))

15

    model.add(tkl.Dropout(float(.5)))     

16

    model.add(tkl.Dense(num_classes))

17

    model.add(tkl.Activation('softmax'))   

18

    model.compile(loss='sparse_categorical_crossentropy',

19

                  optimizer='nadam',metrics=['accuracy'])   

20

    return model

21

kmodel=kmodel(float(.005),num_classes,img_size)

22

fw='/tmp/checkpoint'

23

checkpointer=tkc.ModelCheckpoint(

24

    filepath=fw,verbose=int(0),save_weights_only=True,

25

    monitor='val_accuracy',mode='max',save_best_only=True)

26

history=kmodel.fit(

27

    x_train,y_train,epochs=int(3),batch_size=int(16),verbose=int(2),

28

    validation_data=(x_valid,y_valid),callbacks=[checkpointer])

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

---

Messages

xxxxxxxxxx

 

1

kmodel.load_weights(fw)

2

print(kmodel.evaluate(x_test,y_test,verbose=int(0)))

3

y_cnn_test=np.argmax(kmodel.predict(x_test),axis=-1)

4

os.remove(fw)

5

plot_predict(y_cnn_test,'CNN Keras')

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

---

Messages

✒️ PyTorch

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([int(1),num_features,

6

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

7

        self.register_parameter('gamma',\

8

        tnn.Parameter(torch.empty([int(1),num_features,

9

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

10

        self.register_parameter('tau',\

11

        tnn.Parameter(torch.empty([int(1),num_features,

12

                                   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(kernel_size=int(3),

33

                          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(kernel_size=int(3),

39

                          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,

44

                kernel_size=int(1),stride=int(1),

45

                padding=int(0)),

46

            tnn.ReLU(),

47

            tnn.AvgPool2d(kernel_size=int(8),

48

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

49

    def forward(self,x):

50

        x=self.classifier(x)

51

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

52

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

53

        return logits,probs

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

---

Messages

xxxxxxxxxx

 

1

def model_acc(model,data_loader):

2

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

3

    for features,targets in data_loader:

4

        features=features.to(dev)

5

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

6

        logits,probs=model(features)

7

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

8

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

9

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

10

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

11

def epoch_loss(model,data_loader):

12

    model.eval()

13

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

14

    with torch.no_grad():

15

        for features,targets in data_loader:

16

            features=features.to(dev)

17

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

18

            logits,probs=model(features)

19

            loss=tnnf.cross_entropy(logits,targets,reduction='sum')

20

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

21

            curr_loss+=loss

22

        return curr_loss/num_examples

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

---

Messages

xxxxxxxxxx

 

1

@register_line_magic

2

def train_run(epochs):

3

    epochs=int(epochs)

4

    st1='epoch: %03d/%03d || batch: %03d/%03d || cost: %.4f'

5

    for epoch in range(epochs):

6

        tmodel.train()

7

        for batch_ids,(features,targets) \

8

        in enumerate(dataloaders['train']):        

9

            features=features.to(dev)

10

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

11

            logits,probs=tmodel(features)

12

            cost=tnnf.cross_entropy(logits,targets)

13

            optimizer.zero_grad(); cost.backward()

14

            optimizer.step()

15

            if not batch_ids%int(20):

16

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

17

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

18

        tmodel.eval()

19

        with torch.set_grad_enabled(False):

20

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

21

            print('valid acc/loss: %.2f%%/%.2f'%\

22

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

23

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

24

torch.manual_seed(random_seed); learning_rate=float(.00005)

25

tmodel=FRN_NNinNN(num_classes)

26

tmodel.to(dev)

27

optimizer=torch.optim.Adam(tmodel.parameters(),lr=learning_rate)

28

%train_run 2

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

---

Messages

xxxxxxxxxx

 

1

tmodel.eval()

2

with torch.set_grad_enabled(False):

3

    print('test acc: %.2f%%'%model_acc(tmodel,dataloaders['test']))

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

---

Messages