class Net(nn.Module):

    def __init__(self,batch_sz):
        super(Net, self).__init__()

	self.conv1 = nn.Conv3d(1,30,3,padding=1)
	self.input_bn1=nn.BatchNorm3d(30)

	#self.conv2 = nn.Conv3d(30, 30, 3, padding=1)
 
        self.pool1=nn.MaxPool3d((2, 4, 4), stride=(2,4,4))
	self.input_bn2=nn.BatchNorm3d(30)

	self.conv3 = nn.Conv3d(30, 40, 3, padding=1)
	self.input_bn3=nn.BatchNorm3d(40)

	#self.conv4 = nn.Conv3d(50, 50, 3, padding=1)
        self.pool2=nn.MaxPool3d((2, 2, 2), stride=(2,2,2))

	self.input_bn4=nn.BatchNorm3d(40)

	self.conv5 = nn.Conv3d(40,60, 3, padding=1)
	self.input_bn5=nn.BatchNorm3d(60)

#	self.conv6 = nn.Conv3d(100,100, 3, padding=1)
#	self.input_bn6=nn.BatchNorm3d(100)



	self.lstm1=nn.LSTM(30*17*17*4, 128, 2,batch_first=True,bidirectional=True)
	self.lstm2=nn.LSTM(40*8*8*2, 128, 2,batch_first=True,bidirectional=True)
	self.lstm3=nn.LSTM(60*4*4*1, 128, 2,batch_first=True,bidirectional=True)


	self.linear1=nn.Linear(128*6,500)

	self.dense1_bn = nn.BatchNorm1d(500)

	self.linear2=nn.Linear(500,500)
	
 	self.softmax = nn.LogSoftmax(1)

	self.l1=torch.FloatTensor(np.zeros((batch_sz,7,30*17*17*4))).cuda()
	self.l2=torch.FloatTensor(np.zeros((batch_sz,7,40*8*8*2))).cuda()
	self.l3=torch.FloatTensor(np.zeros((batch_sz,7,60*4*4*1))).cuda()

	
    	for name, param in self.lstm1.named_parameters():
  		if 'bias' in name:
     			nn.init.constant(param, 0.0)
  		elif 'weight' in name:
     			nn.init.xavier_normal(param)

    	for name, param in self.lstm2.named_parameters():
  		if 'bias' in name:
     			nn.init.constant(param, 0.0)
  		elif 'weight' in name:
     			nn.init.xavier_normal(param)

    	for name, param in self.lstm3.named_parameters():
  		if 'bias' in name:
     			nn.init.constant(param, 0.0)
  		elif 'weight' in name:
     			nn.init.xavier_normal(param)


	


    def forward(self, inputs,batch_sz):
		



		for i1 in range(0,batch_sz):

			cnn_feature_1=self.input_bn1(self.pool1(F.relu(self.conv1(inputs[i1]))))

			#cnn_feature_2=self.input_bn2(self.pool1(F.relu(self.conv2(cnn_feature_1))))

			


			self.l1[i1]=cnn_feature_1.view(-1,num_flat_features(cnn_feature_1)).data


			cnn_feature_3=self.input_bn3(self.pool2(F.relu(self.conv3(cnn_feature_1))))

			#cnn_feature_4=self.input_bn4(self.pool2(F.relu(self.conv4(cnn_feature_3))))


			self.l2[i1]=cnn_feature_3.view(-1,num_flat_features(cnn_feature_3)).data


			cnn_feature_5=self.input_bn5(self.pool2(F.relu(self.conv5(cnn_feature_3))))

			#cnn_feature_6=self.input_bn6(self.pool2(F.relu(self.conv6(cnn_feature_5))))

			self.l3[i1]=cnn_feature_5.view(-1,num_flat_features(cnn_feature_5)).data



		packed_input_1 = pack_padded_sequence(Variable(self.l1), np.array([8]*batch_sz,dtype=int),batch_first=True)
		packed_input_2 = pack_padded_sequence(Variable(self.l2), np.array([8]*batch_sz,dtype=int),batch_first=True)
		packed_input_3 = pack_padded_sequence(Variable(self.l3), np.array([8]*batch_sz,dtype=int),batch_first=True)
		#packed_input_4 = pack_padded_sequence(Variable(self.l4), np.array([29]*batch_sz,dtype=int),batch_first=True)
		#packed_input_5 = pack_padded_sequence(Variable(self.l5), np.array([28]*batch_sz,dtype=int),batch_first=True)
		
		packed_output_a, (hta,cta) = self.lstm1(packed_input_1)
		packed_output_b, (htb,ctb) = self.lstm2(packed_input_2)
		packed_output_c, (htc,ctc) = self.lstm3(packed_input_3)
		#packed_output_d, (htd,ctd) = self.lstm4(packed_input_4)
		#packed_output_e, (hte,cte) = self.lstm5(packed_input_5)

		#print(hta)
	
		f_feature=torch.cat((hta[3],htb[3], htc[3],hta[2],htb[2],htc[2]),1)

		print(f_feature)
		
		predictions=self.softmax(self.linear2(self.dense1_bn(self.linear1((f_feature)))))

		

		return predictions


######################################################################################################################################

net=Net(4)
net=net.cuda()
sumloss=0
transformed_dataset_train = bbc_lrw_train_img()
transformed_dataset_test = bbc_lrw_test_img()
transformed_dataset_val = bbc_lrw_val_img()

trainloader = torch.utils.data.DataLoader(transformed_dataset_train, batch_size=4,shuffle=True, num_workers=4,drop_last=True)
print("Data_loader for Train is Ready ")
valloader = torch.utils.data.DataLoader(transformed_dataset_val, batch_size=4,shuffle=True, num_workers=4,drop_last=True)
print("Data_loader for Validation is Ready ")
testloader = torch.utils.data.DataLoader(transformed_dataset_test, batch_size=4,shuffle=True, num_workers=4,drop_last=True)
print("Data_loader for test is Ready ")



#criterion = nn.CrossEntropyLoss()
criterion = nn.NLLLoss()
optimizer = optim.Adam(net.parameters(),lr =0.00001) #lr=0.00002
#optimizer = optim.SGD(net.parameters(), lr =0.00003, momentum=0.9,weight_decay=1e-5)
acc_sum=0
k_z=0
acc_list=[]
epoch=0
while(1):
	epoch=epoch+1
	for i_a, data_a in enumerate(trainloader, 0):
		#print(i_a)


		net.train(False)
		inputs,labels=data_a

		outputs = net(Variable(inputs.cuda()),4)

		#print(outputs.data.max(1)[1])

		labels=Variable(labels.cuda())

		loss = criterion(outputs, labels)
		sumloss=sumloss+loss.data[0]
		#loss.backward()
		##torch.nn.utils.clip_grad_norm(net.parameters(), 400)

		predict1 = outputs.data.max(1)[1]
		acc = predict1.eq(labels.data).cpu().sum()	

		acc_sum += acc

		torch.nn.utils.clip_grad_norm(net.parameters(), 10) 
		optimizer.step()
		optimizer.zero_grad()

I am using LSTM in batch mode, I have a question if hidden needs to be detached here… if yes how ? Is there a solution to this issue of dnn.CuDNNError: 8: CUDNN_STATUS_EXECUTION_FAILED