Pytorch:dtype不一致问题(expecteddtypeDoublebutgotdtypeFloat)

# 将接下来创建的变量类型均为Double
torch.set_default_tensor_type(torch.DoubleTensor)

#将接下来创建的变量类型均为Float
torch.set_default_tensor_type(torch.FloatTensor)

# For your model
net = net.double()
# For your data
net(input_x.double)

conda install pytorch cuda92

# !user/bin/python
# -*- coding: UTF-8 -*-
 
import torch
 
a = torch.arange(16).view(4, 4)
b = torch.argmax(a, dim = 1)
print([round(x.item(), 5) for x in b])
 
z = torch.tensor([3, 1, 2, 5], dtype = torch.long) # 类型必须保持一致
z = z.view(-1, 1)
b = b.view(-1, 1)
print(b)
print(z)
print(b == z)
# tensor([[ True],
#         [False],
#         [False],
#         [False]])
print(torch.sum(b == z)) # tensor(1)

x = np.array([[1, 2, 3], [4, 5, 6]]) # 正确
# x = np.array([[1, 2, 3], [4, 5]]) # 错误
print(torch.from_numpy(x))

import torch
import numpy as np
 
x = torch.tensor([[1, 2], [3, 4]])
print(x)
# tensor([[1, 2],
#         [3, 4]])
 
# 在第0维的地方插入一维
print(x.unsqueeze(0))
# tensor([[[1, 2],
#          [3, 4]]])
print(x.unsqueeze(0).shape) # torch.Size([1, 2, 2])
print(x.unsqueeze(1))
# tensor([[[1, 2]],
 
#         [[3, 4]]])
print(x.unsqueeze(1).shape) # torch.Size([2, 1, 2])

# !user/bin/Python
# -*- coding: UTF-8 -*-
 
import torch
import torch.nn as nn
import torch.nn.functional as F
 
# 看看torch中的torch.nn.embedding
# embedding接收两个参数
# 第一个是num_embeddings，它表示词库的大小，则所有词的下标从0 ~ num_embeddings-1
# 第二个是embedding_dim，表示词嵌入维度
# 词嵌入层有了上面这两个必须有的参数，就形成了类，这个类可以有输入和输出
# 输入的数据结构不限，但是数据结构里面每个单元的元素必须指的是下标，即要对应0 ~ num_embeddings-1
# 输出的数据结构和输入一样，只不过将下标换成对应的词嵌入
# 最开始的时候词嵌入的矩阵是随机初始化的，但是作为嵌入层，会不断的学习参数，所以最后训练完成的参数一定是学习完成的
# embedding层还可以接受一个可选参数padding_idx，这个参数指定的维度，但凡输入的时候有这个维度，输出一律填0
 
# 下面来看一下吧
embedding = nn.Embedding(10, 3)
inputs = torch.tensor([[1, 2, 4, 5],
                       [4, 3, 2, 9]])
print(embedding(inputs))
 
# tensor([[[ 0.3721,  0.3502,  0.8029],
#          [-0.2410,  0.0723, -0.6451],
#          [-0.4488,  1.4382,  0.1060],
#          [-0.1430, -0.8969,  0.7086]],
#
#         [[-0.4488,  1.4382,  0.1060],
#          [ 1.3503, -0.0711,  1.5412],
#          [-0.2410,  0.0723, -0.6451],
#          [-0.3360, -0.7692,  2.2596]]], grad_fn=<EmbeddingBackward>)

# !user/bin/python
# -*- coding: UTF-8 -*-
 
 
# eq
import torch
a = torch.tensor([1, 2, 2, 3])
b = torch.tensor((1, 3, 2, 3))
print(a.eq(b)) # tensor([ True, False,  True,  True])
print(a.eq(0)) # tensor([False, False, False, False])
print(a.eq(2)) # tensor([False,  True,  True, False])

# expand
# expand不修改原有值
# 只能扩展维度是1的那个维度
# 另外，expand还能增加新的维度，不过新的维度必须在已知维度之前比如从2 * 3 到 5 * 2 * 3
a = torch.tensor([[1, 2, 3]])
print(a.size()) # torch.Size([1, 3])，第一维是1，所以只能扩展第一维
print(a.expand(3, 3))
# tensor([[1, 2, 3],
#         [1, 2, 3],
#         [1, 2, 3]])
print(a) # tensor([[1, 2, 3]])
 
a = torch.tensor([[1], [2], [3]])
print(a.size()) # torch.Size([3, 1])，第二维是1，只能扩展第二维
print(a.expand(-1, 4)) # 第一维用-1代表第一维不变，还是3
# tensor([[1, 1, 1, 1],
#         [2, 2, 2, 2],
#         [3, 3, 3, 3]])
 
a = torch.randn(2, 1, 1, 4) # 同理，只能扩展第2和第3维
print(a.expand(-1, 2, 3, -1))
 
a = torch.tensor([1, 2, 3])
print(a.size()) # torch.Size([3])
print(a.expand(2, 3))
# tensor([[1, 2, 3],
#         [1, 2, 3]])
# print(a.expand(3, 2)) 会报错，因为新维度跑到原有维度之后了
print(a.expand(3, 2, -1))
 
a = torch.rand(2, 3)
print(a.expand(5, 2, 3)) # 正确

# repeat
# repeat不改变原有值
# repeat传入的参数的个数等于原有值的维度个数，表示将对应维度的内容重复多少次
 
a = torch.tensor([1, 2, 3]) # size = [3]
print(a.repeat(2)) # 将第一个维度的重复两次 tensor([1, 2, 3, 1, 2, 3])
print(a) # tensor([1, 2, 3])
 
a = torch.tensor([[1, 2, 3], [4, 5, 6]]) # 2 * 3
print(a.repeat(2, 3)) # 第一维重复两次，第二维重复三次，就变成了4 * 9
# tensor([[1, 2, 3, 1, 2, 3, 1, 2, 3],
#         [4, 5, 6, 4, 5, 6, 4, 5, 6],
#         [1, 2, 3, 1, 2, 3, 1, 2, 3],
#         [4, 5, 6, 4, 5, 6, 4, 5, 6]])

class CrossEntropyLoss(_WeightedLoss):
    def __init__(self, weight=None, size_average=None, ignore_index=-100,
                 reduce=None, reduction='mean'):
        super(CrossEntropyLoss, self).__init__(weight, size_average, reduce, reduction)
        self.ignore_index = ignore_index
 
    def forward(self, input, target):
        return F.cross_entropy(input, target, weight=self.weight,
                               ignore_index=self.ignore_index, reduction=self.reduction)