Hey there, below is part of my code
class ContentLoss(nn.Module):
    def __init__(self,target,weight):
        super(ContentLoss,self).__init__()
        #detach the original computing graph->weight graph
        self.target=target.detach()*weight
        self.weight=weight
        self.criterion=nn.MSELoss()
    def forward(self,input):
        self.loss=self.criterion(input*self.weight,self.target)#MSE LOSS
        self.output=input
        return self.output
    def backward(self,retain_graph=True):
        self.loss.backward(retain_graph=retain_graph)
        return self.loss
======
class StyleLoss(nn.Module):
    def __init__(self,target,weight):
        super(StyleLoss,self).__init__()
        self.target=target.detach()*weight
        self.weight=weight
        #self.gram=GramMatrix()
        self.criterion=nn.MSELoss()
    def forward(self,input):
        self.output=input.clone()
        input=input.cuda()
        self_G=Gram(input)
        self_G.mul_(self.weight)
        self.loss=self.criterion(self_G,self.target)
        return self.output
    def backward(self,retain_graph=True):
        self.loss.backward(retain_graph=retain_graph)
        return self.loss
def Gram(input):
    a,b,c,d=input.size()#a=batch_size,b=number of features (c,d)=N=c*d->dimension of visualization
    features=input.view(a*b,c*d)
    G=torch.mm(features,features.t())
    return G.div(a*b*c*d)
=====
content_losses=[]
style_losses=[]
model=nn.Sequential()
model=model.cuda()
i=1
for layer in list(cnn):
    if isinstance(layer,nn.Conv2d):
        name="conv_"+str(i)
        model.add_module(name,layer)
    if name in content_layers:
        target=model(content_img).clone()
        content_loss=ContentLoss(target,content_weight)#content_weight=1000
        content_loss=content_loss.cuda()
        model.add_module("content_loss"+str(i),content_loss)
        content_losses.append(content_loss)
    if name in style_layers:
        target_feature=model(style_img).clone()
        target_feature=target_feature.cuda()
        #print(target_feature)
        target_feature_gram=Gram(target_feature)
        style_loss=StyleLoss(target_feature_gram,style_weight)#style_weight=1
        style_losses.append(style_loss)
    if isinstance(layer,nn.ReLU):
        name="ReLU"+str(i)
        model.add_module(name,layer)
        print(i)
        i+=1
    if isinstance(layer,nn.MaxPool2d):
        name="MaxPool"+str(i)
        model.add_module(name,layer)
==========
input_param=nn.Parameter(input_img.data)
optimizer=optim.LBFGS([input_param])
num_steps=300
for i in range(num_steps):
    input_param.data.clamp_(0,1)
    optimizer.zero_grad()
    model(input_param)
    style_score=0
    content_score=0
    for sl in style_losses:
       -------------------------------->>> style_score+=sl.backward()
    for cl in content_losses:
       -------------------------------->>> content_score+=cl.backward()
    if i%50==0:
        print("num{}epochs".format(i))
        print("StyleLoss{:4f},Content_loss{:4f}".format(style_score.data[0],content_score.data[0]))
    def closure():
        return style_score+content_score
output=input_param.data.clamp_(0,1)
plt.figure()
inshow(output,title="output Image")
plt.ioff()
plt.show()

And the Error:
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-67-2426f976e393> in <module>
      1 for sl in style_losses:
----> 2         style_score+=sl.backward()

c:\python36\lib\site-packages\torch\nn\modules\module.py in __getattr__(self, name)
    589                 return modules[name]
    590         raise AttributeError("'{}' object has no attribute '{}'".format(
--> 591             type(self).__name__, name))
    592 
    593     def __setattr__(self, name, value):

AttributeError: 'StyleLoss' object has no attribute 'loss'
==============

I have defined the loss in the class self.loss why the torch can’t find it?