If you want to experiment with PyTorch

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,torch

8

from sklearn.datasets import make_classification

9

dev=torch.device('cuda:0' \

10

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

11

class Perceptron():

12

    def __init__(self,num_features):

13

        self.num_features=num_features

14

        self.weights=torch.zeros(num_features,int(1), 

15

                                 dtype=torch.float32,device=dev)

16

        self.bias=torch.zeros(1,dtype=torch.float32,device=dev)

17

    def forward(self,x):

18

        values=torch.add(torch.mm(x,self.weights),self.bias)

19

        a=torch.ones(values.size()[0],int(1))

20

        b=torch.zeros(values.size()[0],int(1))

21

        predictions=torch.where(values>float(0.),a,b).float()

22

        return predictions        

23

    def backward(self,x,y):  

24

        predictions=self.forward(x)

25

        errors=y-predictions

26

        return errors        

27

    def train(self,x,y,epochs):

28

        for e in range(epochs):            

29

            for i in range(y.size()[0]):

30

                errors=self.backward(

31

                    x[i].view(int(1),self.num_features),

32

                    y[i]).view(-int(1))

33

                self.weights+=(errors*x[i]).view(

34

                    self.num_features,int(1))

35

                self.bias+=errors                

36

    def acc(self,x,y):

37

        predictions=self.forward(x).view(-int(1))

38

        accuracy=torch.sum(predictions==y).float()/y.size()[0]

39

        return accuracy

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

---

Messages

xxxxxxxxxx

 

1

N=500; n=int(.2*N)

2

X,y=make_classification(

3

    n_samples=N,n_features=2,n_redundant=0,n_informative=2)

4

mu,std=np.mean(X,axis=0),np.std(X,axis=0)

5

X=(X-mu)/std

6

X,y=X.astype('float32'),y.astype('int32')

7

shuffle_ids=np.arange(N)

8

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

9

X,y=X[shuffle_ids],y[shuffle_ids]

10

X_test,X_train=X[:n],X[n:]

11

y_test,y_train=y[:n],y[n:]

12

model=Perceptron(num_features=2)

13

tX_train=torch.tensor(

14

    X_train,dtype=torch.float32,device=dev)

15

ty_train=torch.tensor(

16

    y_train,dtype=torch.float32,device=dev)

17

model.train(tX_train,ty_train,epochs=int(5))

18

tX_test=torch.tensor(

19

    X_test,dtype=torch.float32,device=dev)

20

ty_test=torch.tensor(

21

    y_test,dtype=torch.float32,device=dev)

22

acc_test=model.acc(tX_test,ty_test).numpy()

23

print('Test accuracy: %.2f%%'%(acc_test*int(100)))

24

W,b=model.weights.numpy(),model.bias.numpy()

25

x_min=-int(2); x_max=int(2)

26

y_min=((-(W[int(0)]*x_min)-b[int(0)])/W[int(1)])

27

y_max=((-(W[int(0)]*x_max)-b[int(0)])/W[int(1)])

28

fig,ax=pl.subplots(2,1,sharex=True,figsize=(6.5,6))

29

ax[0].plot([x_min,x_max],[y_min,y_max],c='red')

30

ax[1].plot([x_min,x_max],[y_min,y_max],c='red')

31

ax[0].scatter(X_train[:,0],X_train[:,1],

32

              c=y_train,s=10,cmap=pl.cm.cool)

33

ax[1].scatter(X_test[:,0], X_test[:,1],

34

              c=y_test,s=10,cmap=pl.cm.cool)

35

ax[0].grid(); ax[1].grid()

36

pl.tight_layout(); pl.show()

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

---

Messages