写了这么久，终于有感觉了。以后再编辑文章，要慢慢趋与条例性
一、有关CrossEntropyloss() 二、有关多分类的一个RNN模型实例 一、有关CrossEntropyloss()crossentropyloss()就干两件事，一是softmax()运算，二是-y*log(y_pred)
图片中的意思是，我有一个样本数据他们是[[0.2,0.1,-0.1]]。（用一个中括号他的size是3，而用两个中括号size是[1,3]。这点是新手非常容易忽视的。）它的含义是我这个样本可能属于三个分类（第0类，第一类，第二类）中的一个，而数值的大小表示了可能性的大小（后面经过运算会变成概率，但此时他们之间的概率大小关系已经很明确了）。这个样本数据的标签是[0]它是第0类(如果是[1]表示第一类，[2]表示第二类)。
而crossentropyloss()的作用开始：
1，求指数运算：[0.2,0.1,-0.1] ->[0.38,0.34,0.28]。
2，运算-y*log(y_pred)（是第0类y:[1,0,0], -y*log(0.38)
第一类y:[0,1,0] -y*log(0.34)
第二类y:[0,0,1]） -y*log(0.28))
代码：
import math
x = torch.Tensor([[0.2,0.1,-0.1]])
y = torch.LongTensor([0])
criterion = torch.nn.CrossEntropyLoss()
loss = criterion(x,y)
print("loss1",loss) #loss1 tensor(0.9729)
print("math.log(0.38)",-math.log(0.38)) #math.log(0.38) 0.9675840262617056
【一些注意】
x的Tensor()要大写，这里没有要求是LongTensor()但后面例子要用LongTensor()(x如果用了LongTensor()会报错)x的size（batchsize,seq_len）(1,3)
y的要求必须是LongTensor() (bacth*seq_len) (1)
【搞复杂一丢丢】
x = torch.Tensor([[0.2,0.1,-0.1],[0.8,0.5,-0.6]])
y = torch.LongTensor([2,1])
criterion = torch.nn.CrossEntropyLoss()
loss = criterion(x,y)
print("loss1",loss)
【有两个样本他们分别是第二类，第一类，x的[0.2,0.1,-0.1]表示第一个样本属于第0类，第一类，第二类的机会大小。x的[0.8,0.5，-0.6]表示第二个样本属于第0类，第一类，第二类的机会大小】
二，有关RNN模型的实例 一、数据准备input_size = 6 hidden_size = 8 batch_size = 1 num_layers =2 seq_len = 6 num_class = 5 embedding_size = 10 idxchar = ['e','h','l','o','u'] #字典 x_data = [1,0,2,2,3,4] #[hellou] y_data = [3,1,2,3,2,4] #[ohl0lu] inputs = torch.LongTensor(x_data) #LongTensor() inputs =inputs.view(batch_size,seq_len) labels = torch.LongTensor(y_data)
【注意】inputs的类型是LongTensor()。它的size是【batch_size,seq_len】（1,6）
二、构建模型
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.emb = torch.nn.Embedding(input_size,embedding_size)
self.rnn = nn.RNN(input_size = embedding_size,hidden_size=hidden_size,num_layers=num_layers,batch_first=True)
self.fc = torch.nn.Linear(hidden_size,num_class)
def forward(self,x):
hidden = torch.zeros(num_layers,x.size(0),hidden_size)
x = self.emb(x)
print('self.emb(x)',x.shape)
x,_ = self.rnn(x,hidden)
print('out1.shape',x.shape)
x=self.fc(x)
print('out.shape:',x.shape)
print('out',x)
return x.view(-1,num_class)
net = Model()
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(),lr=0.1)
三、训练
for epoch in range(3):
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs,labels)
loss.backward()
optimizer.step()
_,idx = outputs.max(dim=1)
#print('idx',idx)
#idx = idx.data.numpy()
#print('pred:',''.join([idxchar[x] for x in idx]),end='')
print(',Epoch[%d/15] loss = %4f'%(epoch+1,loss))
【整体思路为】x_data的[1,6],embedding为[1,6,10]，然后linear为[1,6,5],再view为[6,5],然后计算loss
我后面又对模型进行了大改
class Model(nn.Module):
def __init__(self,input_size,embedding_size,hidden_size,num_layers,num_class):
super(Model, self).__init__()
self.input_size = input_size
self.embedding_size = embedding_size
self.hidden_size = hidden_size
self.num_layers = num_layers
self.num_class = num_class
self.emb = torch.nn.Embedding(self.input_size,self.embedding_size)
self.rnn = nn.RNN(input_size = self.embedding_size,hidden_size=self.hidden_size,num_layers=self.num_layers,batch_first=True)
self.fc = torch.nn.Linear(self.hidden_size,self.num_class)
def forward(self,x,hidden):
#hidden = torch.zeros(num_layers,x.size(0),hidden_size)
x = self.emb(x)
print('self.emb(x)',x.shape)
x,_ = self.rnn(x,hidden)
print('out1.shape',x.shape)
x=self.fc(x)
print('out.shape:',x.shape)
print('out',x)
return x.view(-1,self.num_class),_
def init_hidden(self,batch_size):
hidden= torch.zeros(self.num_layers,batch_size,self.hidden_size)
return hidden
net = Model(input_size,embedding_size,hidden_size,num_layers,num_class)
for epoch in range(15):
optimizer.zero_grad()
hs = net.init_hidden(batch_size)
outputs,h = net(inputs,hs)
print('outputs',outputs.shape)
#print('_',h)
loss = criterion(outputs,labels)
loss.backward()
optimizer.step()
_,idx = outputs.max(dim=1)
print('_',_)
print('idx',idx)
idx = idx.data.numpy()
print('pred:',''.join([idxchar[x] for x in idx]),end='')
print(',Epoch[%d/15] loss = %4f'%(epoch+1,loss))
