Hi
can anyone help me how to solve this problem please 
model = ViolenceModel(modelUsed,pretrained)
svclassifier = SVC(kernel='linear')
trainParams = []
for params in model.parameters():
if params.requires_grad:
trainParams += [params]
model.train(True)
if(torch.cuda.is_available()):
model.cuda()
lossFn = nn.CrossEntropyLoss()
optimizerFn = torch.optim.RMSprop(trainParams, lr=lr)
optimizerFn.zero_grad()
optimScheduler = torch.optim.lr_scheduler.StepLR(optimizerFn, stepSize, decayRate)
minAccuracy = 50
train_loss=[]
val_loss=[]
train_acc=[]
val_acc=[]
bestmodel=None
for epoch in range(numEpochs):
optimScheduler.step()
epochLoss = 0
numCorrTrain = 0
iterPerEpoch = 0
print('Epoch = {}'.format(epoch + 1))
writer.add_scalar('lr', optimizerFn.param_groups[0]['lr'], epoch+1)
for i, (inputs, targets) in enumerate(trainLoader):
iterPerEpoch += 1
optimizerFn.zero_grad()
if(torch.cuda.is_available()):
inputVariable1 = Variable(inputs.permute(1, 0, 2, 3, 4).cpu())
labelVariable = Variable(targets.cpu())
else:
inputVariable1=Variable(inputs.permute(1,0,2,3,4))
labelVariable=Variable(targets)
print(inputVariable1.shape)
svclassifier.fit(model,labelVariable)
outputLabel = svclassifier.predict(model)
loss = lossFn(outputLabel, labelVariable)
loss.backward()
optimizerFn.step()
#outputProb = torch.nn.Softmax(dim=1)(outputLabel)
#_, predicted = torch.max(outputProb.data, 1)
_, predicted = outputLabel
if(torch.cuda.is_available()):
numCorrTrain += (predicted == targets.cuda()).sum()
else:
numCorrTrain+=(predicted==targets).sum()
epochLoss += loss.item()
avgLoss = epochLoss/iterPerEpoch
trainAccuracy = (float(numCorrTrain) * 100)/float(numTrainInstances)
train_loss.append(avgLoss)
train_acc.append(trainAccuracy)
print('Training: Loss = {} | Accuracy = {}% '.format(avgLoss, trainAccuracy))
writer.add_scalar('train/epochLoss', avgLoss, epoch+1)
writer.add_scalar('train/accuracy', trainAccuracy, epoch+1)
trainLogLoss.write('Training loss after {} epoch = {}\n'.format(epoch+1, avgLoss))
trainLogAcc.write('Training accuracy after {} epoch = {}\n'.format(epoch+1, trainAccuracy))
model:
import torch.nn as nn
from torchvision import models
from ConvLSTMCell import *
from efficientnet_pytorch import EfficientNet
from sklearn.svm import SVC
class ViolenceModel(nn.Module):
def __init__(self,modelused,pretrained):
super(ViolenceModel, self).__init__()
if modelused=='alexnet':
self.mod=models.alexnet(pretrained=pretrained)
self.convNet = nn.Sequential(*(list(self.mod.children()))[:-1])
self.mem_size=256
self.conv_lstm = ConvLSTMCell(256, self.mem_size)
if pretrained:
for param in self.convNet.parameters():
param.requires_grad = False
def forward(self, x):
state = None
seqLen = x.size(0) - 1
for t in range(0, seqLen):
x1 = x[t] - x[t+1]
x1 = self.convNet(x1)
state = self.conv_lstm(x1, state)
x = self.maxpool(state[0])
x= x.view(x.size(0), -1)
return x
