I have a SGD perceptron training algorithm. I would like to modify this code to include different batch sizes with 5-fold cross validation.

Question

def perce_online(X,y,w_ini,rho):

  (l,N) = np.shape(X)

  max_iter=500000

  w=np.reshape(w_ini,(3,1));

  iter=0;

  mis_clas=N;

  while mis_clas>0 and iter<max_iter:

    mis_clas=0

    for i in range(N):

      if np.dot((X[:,i]),w)*y[i]<0:

          mis_clas=mis_clas+1

          w=w+np.reshape(rho*y[i]*X[:,i],(3,1))

      iter=iter+1

  return w,iter,mis_clas

N= [100,100]

l=2

np.random.seed(0)

x=[3,3]

X1=np.concatenate((2*np.random.rand(l,N[0]),2*np.random.rand(l,N[1])+np.concatenate((np.ones((1,N[1]))*x[0],np.ones((1,N[1]))*x[1]),axis=0)),axis=1)

X1=np.concatenate((X1,np.ones((1,sum(N)))),axis=0)

y1=np.concatenate((np.ones((1,N[0])),-np.ones((1,N[1]))),axis=1)[0]

print(y1.shape)

plt.plot(X1[0,:100],X1[1,:100],'bo',X1[0,100:],X1[1,100:],'r.')

rho=0.01

w_ini=np.transpose([1,1,.5]);

w,iter,mis_clas=perce_online(X1,y1,w_ini,rho)

print('Number of iterations=',iter)

Xtrain has dimensions 90, 2

Xval has dimensions 30, 2

Xtest has dimensions 30, 2

Ytrain has dimensions 90, 1

Yval has dimensions 30, 1

Ytest has dimensions 30, 1

Answer 1

Hi Joan,

To modify the code for 5-fold cross-validation with different batch sizes, you can follow these steps:

1. Divide your data into 5 folds.

2. Train and validate the perceptron algorithm on each fold.

3. Average the results for a more robust estimate of the model's performance.

Here's an updated version of your code with 5-fold cross-validation and the ability to specify different batch sizes:

```python

import numpy as np

import matplotlib.pyplot as plt

def perce_online(X, y, w_ini, rho):

(l, N) = np.shape(X)

max_iter = 500000

w = np.reshape(w_ini, (3, 1))

iter = 0

mis_clas = N

while mis_clas > 0 and iter < max_iter:

mis_clas = 0

# Shuffle the data

indices = np.arange(N)

np.random.shuffle(indices)

X = X[:, indices]

y = y[indices]

for i in range(N):

if np.dot(X[:, i], w) * y[i] < 0:

mis_clas += 1

w = w + np.reshape(rho * y[i] * X[:, i], (3, 1))

iter += 1

return w, iter, mis_clas

def k_fold_cross_validation(X, y, k, rho, batch_size):

fold_size = len(X) // k

total_iter = 0

total_mis_clas = 0

for i in range(k):

start, end = i * fold_size, (i + 1) * fold_size

X_val, y_val = X[:, start:end], y[start:end]

X_train = np.concatenate([X[:, :start], X[:, end:]], axis=1)

y_train = np.concatenate([y[:start], y[end:]])

w_ini = np.transpose([1, 1, 0.5])

w, iter, mis_clas = perce_online(X_train, y_train, w_ini, rho)

total_iter += iter

total_mis_clas += mis_clas

avg_iter = total_iter // k

avg_mis_clas = total_mis_clas // k

return avg_iter, avg_mis_clas

# Your data

Xtrain, Xval, Xtest = ..., ..., ...

Ytrain, Yval, Ytest = ..., ..., ...

# Concatenate X and Y for training

train_data = np.concatenate((Xtrain, Ytrain), axis=1)

# Define parameters

rho = 0.01

batch_sizes = [10, 20, 30] # You can modify these as needed

num_folds = 5

for batch_size in batch_sizes:

avg_iter, avg_mis_clas = k_fold_cross_validation(train_data, Ytrain, num_folds, rho, batch_size)

print(f'Batch Size: {batch_size}, Average Number of Iterations: {avg_iter}, Average Number of Misclassifications: {avg_mis_clas}')

'''

Replace `...` in the data loading part with your actual data. This code defines a function `k_fold_cross_validation` to perform k-fold cross-validation with different batch sizes and prints the average number of iterations and misclassifications for each batch size. Adjust the parameters according to your needs.

'''