Question

Convert THE CODE BELOW to a 3-class classifier (or rewrite it in Python in the same style – level of abstraction) for the Iris dataset. Decide the best subset of 2-variables for the classification task.

close all
clear
load fisheriris
ntr=75;
nts = size(meas,1) - ntr;

%rand('seed',12345)
rp=randperm(150);

usevars = [1, 2];
predvar = 4;
trainx=[ones(ntr,1) meas(rp(1:ntr),usevars)];
trainr=meas(rp(1:ntr),predvar);

testx=[ones(nts,1) meas(rp(ntr+1:150),usevars)];
testr=meas(rp(ntr+1:150),predvar);

H=50;
I=size(trainx,2);

w=rand(H,I)*0.2-0.1;
v=rand(1,H+1)*0.02-0.01;
v(1)=mean(trainr);

Nepochs=1000;
MSEtrain = zeros(1,Nepochs);
MSEtest = zeros(1,Nepochs);

lr = 0.01;
for epoch = 1:Nepochs
    %dw = zeros(size(w));
    for t = randperm(ntr)
        
        x = trainx(t,:)';
        z = logsig(w*x);
        z = [1; z];
        y = v * z;
        r = trainr(t);
        
        dv = (r-y)*z';
        
        for h = 2:H+1
            for i = 1 : I
                dw(h-1,i) = (r - y) * v(h) * z(h)*(1-z(h)) * x(i);
            end
        end
        v = v + lr*dv;
        w = w + lr*dw;
%        MSEtrain(epoch) = MSEtrain(epoch) + (r - y).^2;
    end    
    
    for t = 1:ntr 
        x = trainx(t,:)';
        z = logsig(w*x);
        z = [1; z];
        ytest = v * z;
        MSEtrain(epoch) = MSEtrain(epoch) + ((trainr(t) - ytest).^2);
    end
    
    for t = 1:nts
        x = testx(t,:)';
        z = logsig(w*x);
        z = [1; z];
        ytest = v * z;
        MSEtest(epoch) = MSEtest(epoch) + ((testr(t) - ytest).^2);
    end
end

MSEtrain = MSEtrain / ntr;
MSEtest = MSEtest / nts;
MSEdummy = mean((testr-mean(trainr)).^2);

plot(MSEtrain,'b'), hold on
plot(MSEtest,'r'), 
plot([1 Nepochs],[MSEdummy MSEdummy])

Answer 1

Answer: See the code for 3-class classification of iris dataset in python.

-------------------------------------------

#imports
import pandas as pd
import sklearn as skl

#import dataset iris
iris_dataset = skl.datasets.load_iris()
#print(len(iris_dataset))

#input data
input_data = iris_dataset.data
#output data
output_data = iris_dataset.target

#preparing data for classification
iris_inputdata = pd.DataFrame(input_data,columns=['SepalLength','SepalWidth','PetalLength','PetalWidth'])
iris_classdata = pd.DataFrame(output_data,columns=['Species'])
iris_data = pd.concat([iris_inputdata,iris_classdata],axis=1)

#perform classification using LogisticsRegression
logsig_reg = skl.linear_model.LogisticRegression()
input_train, input_test, output_train, output_test = skl.model_selection.train_test_split(input_data,output_data,test_size = 0.2,random_state = 3)
logsig_reg.fit(input_train,output_train) #perform training

#perform prediction
output_predicted = logsig_reg.predict(input_test)

#test accuracy of classification
class_accuracy = skl.metrics.accuracy_score(output_test,output_predicted)
print("Accuracy of classification: ",class_accuracy)

-----------------------------------------------

Note: In this code, inbuilt dataset iris in scikit-learn library is used.