作业答案

day01

• 1.使用torch.tensor()、torch.arange()和torch.randn()分别创建一个形状为(3, 4)的张量，并打印。
• 2.创建一个形状为(5,10)的全0张量 和 全1张量，并打印。
• 3.使用torch.randint()创建一个形状为(3, 4)的随机整数张量,并将元素类型转换为torch.float32，并打印。
• 4.使用torch.rand()创建一个形状为(3, 4)的张量，然后转换为numpy数组，然后更改其中的一个元素为42，然后再转换为张量，并打印。
• 5.创建一个标量张量，并转换为 python数值，并打印。

# 1.使用torch.tensor()、torch.arange()和torch.randn()分别创建一个形状为(3, 4)的张量，并打印
import torch

# 创建一个形状为(3, 4)的张量
t1 = torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(f"t1: {t1}")
# 使用torch.arange()创建一个形状为(3, 4)的张量
t2 = torch.arange(1, 13).reshape(3, 4)
print(f"t2: {t2}")
# 使用torch.randn()创建一个形状为(3, 4)的张量
t3 = torch.randn(3, 4)
print(f"t3: {t3}")

t1: tensor([[ 1,  2,  3,  4],
        [ 5,  6,  7,  8],
        [ 9, 10, 11, 12]])
t2: tensor([[ 1,  2,  3,  4],
        [ 5,  6,  7,  8],
        [ 9, 10, 11, 12]])
t3: tensor([[ 0.5081, -0.2216, -0.2112, -0.8687],
        [ 0.1202,  2.4337, -1.0001, -0.5479],
        [-0.1211, -0.2320, -0.5798, -0.0413]])

# 2.创建一个形状为(5,10)的全0张量 和 全1张量，并打印。
import torch

# 创建一个形状为(5,10)的全0张量
t1 = torch.zeros(5, 10)
print(f"t1: {t1}")

# 创建一个形状为(5,10)的全1张量
t2 = torch.ones(5, 10)
print(f"t2: {t2}")

t1: tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])
t2: tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])

# 3.使用torch.randint()创建一个形状为(3, 4)的随机整数张量,并将元素类型转换为torch.float32，并打印。
import torch

# 创建一个形状为(3, 4)的随机整数张量
t1 = torch.randint(0, 10, (3, 4))

# 将元素类型转换为torch.float32
# t1 = t1.type(torch.float32)
t1 = t1.to(torch.float32)

# 打印张量
print(t1)

tensor([[2., 4., 9., 9.],
        [8., 5., 8., 4.],
        [7., 3., 9., 3.]])

# 4.使用torch.rand()创建一个形状为(3, 4)的张量，然后转换为numpy数组，然后更改其中的一个元素为42，然后再转换为张量，并打印。
import torch

# 创建一个形状为(3, 4)的随机张量
t1 = torch.rand(3, 4)
print(f"原始张量: {t1}")

# 将张量转换为numpy数组
t1_np = t1.numpy()
print(f"numpy数组: {t1_np}")

# 更改numpy数组中的某个元素为42
t1_np[0, 0] = 42
print(f"更改后的numpy数组: {t1_np}")
# 将numpy数组转换为张量
t1 = torch.tensor(t1_np)
print(f"转换后的张量: {t1}")

原始张量: tensor([[0.2265, 0.5340, 0.4939, 0.7156],
        [0.7442, 0.6439, 0.3041, 0.5015],
        [0.3087, 0.5015, 0.0788, 0.6442]])
numpy数组: [[0.22649407 0.5339812  0.49387354 0.71557003]
 [0.7442052  0.6439322  0.30407512 0.50146997]
 [0.30869353 0.5014638  0.07881838 0.644166  ]]
更改后的numpy数组: [[42.          0.5339812   0.49387354  0.71557003]
 [ 0.7442052   0.6439322   0.30407512  0.50146997]
 [ 0.30869353  0.5014638   0.07881838  0.644166  ]]
转换后的张量: tensor([[42.0000,  0.5340,  0.4939,  0.7156],
        [ 0.7442,  0.6439,  0.3041,  0.5015],
        [ 0.3087,  0.5015,  0.0788,  0.6442]])

# 5.创建一个标量张量，并转换为 python数值，并打印。
import torch
t1 = torch.tensor(10)
print(f"t1: {t1}")
print(f"t1.item(): {t1.item()}")

t1: 10
t1.item(): 10

day02

• 1.使用torch.tensor()创建两个形状为(3,4)的张量t1和t2，计算(t1+t2-2)*2, 并打印。
• 2.使用torch.arange创建一个形状为(3,4)的张量t1,创建一个形状为(3,4)的随机张量t2，计算t1*t2,然后将t2转换形状为(4,3)，注意不要改变t2中元素顺序，计算t1@t2,并打印。
• 3.使用torch.randint()创建一个形状为(3,4)的随机整数张量,求所有元素的均值 和 第1个轴的均值，并打印。(注意元素类型转换)
• 4.使用torch.randint()创建一个形状为(3,4)的张量，获取第2个轴的 索引为1的所有数据，然后获取第二个轴的 索引为1的 大于5的元素 对应的 第一个轴的数据，并打印。
• 5.创建一个两个形状为(3,4)的随机张量t1和t2，都转换形状为(4,3), 然后按0轴进行拼接，得到形状为(8,3)的张量，并打印。
• 6.创建一个形状为(3)的随机张量w，开启requires_grad, 计算loss = 0.5*w**2, 使用loss.mean().backward()获取梯度，并打印梯度w.grad。（尝试手动计算梯度）

# 1.使用torch.tensor()创建两个形状为(3, 4)的张量t1和t2，计算(t1+t2-2)*2, 并打印。
import torch

t1 = torch.tensor(
    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
    )
t2 = torch.tensor(
    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
    )

t3 = (t1 + t2 - 2) * 2
print(f"(t1 + t2 - 2) * 2:\n {t3}")

(t1 + t2 - 2) * 2:
 tensor([[ 0,  4,  8, 12],
        [16, 20, 24, 28],
        [32, 36, 40, 44]])

# 2.使用torch.arange创建一个形状为(3,4)的张量t1,创建一个形状为(3,4)的随机张量t2，计算t1*t2,然后将t2转换形状为(4,3)，注意不要改变t2中元素顺序，计算t1@t2,并打印。
import torch
t1 = torch.arange(12).reshape(3, 4)
t2 = torch.randint(1,10, (3, 4))
print(f"t1: {t1}")
print(f"t2: {t2}")
t3 = t1 * t2
print(f"t1*t2: {t3}")
t2 = t2.reshape(4, 3)
t4 = t1 @ t2
print(f"t1@t2: {t4}")

t1: tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
t2: tensor([[7, 9, 1, 5],
        [5, 2, 5, 3],
        [7, 1, 8, 5]])
t1*t2: tensor([[ 0,  9,  2, 15],
        [20, 10, 30, 21],
        [56,  9, 80, 55]])
t1@t2: tensor([[ 18,  35,  31],
        [ 90, 135,  91],
        [162, 235, 151]])

# 3.使用torch.randint()创建一个形状为(3, 4)的随机整数张量,求所有元素的均值 和 第1个轴的均值，并打印。(注意元素类型转换)
import torch

# 创建一个形状为(3, 4)的随机整数张量
t1 = torch.randint(0, 10, (3, 4))
t1 = t1.to(torch.float32)
# 计算所有元素的均值
mean_all = torch.mean(t1)
print(f"所有元素的均值: {mean_all}")

# 计算第1个轴 / 0轴 的均值
mean_axis_0 = torch.mean(t1, dim=0)
print(f"第1个轴的均值: {mean_axis_0}")

所有元素的均值: 4.916666507720947
第1个轴的均值: tensor([3.6667, 5.0000, 6.0000, 5.0000])

# 4.使用torch.randint()创建一个形状为(3, 4)的张量，获取第2个轴的 索引为1的所有数据，然后获取第二个轴的 索引为1的 大于5的元素 对应的 第一个轴的数据，并打印。
import torch

# 创建一个形状为(3, 4)的随机张量
t1 = torch.randint(0, 10, (3, 4))
print(f"t1: {t1}")

# 获取第2个轴的 索引为1的所有数据
t1_2 = t1[:, 1]
print(f"第2个轴的 索引为1的所有数据: {t1_2}")

# 获取第二个轴的 大于5的元素 对应的 所有轴的数据
t2 = t1[t1[:, 1] > 5]
print(f"第二个轴的 索引为1的 大于5的元素 对应的 第一个轴的数据: {t2}")

t1: tensor([[3, 8, 1, 8],
        [7, 3, 2, 0],
        [7, 5, 7, 2]])
第2个轴的 索引为1的所有数据: tensor([8, 3, 5])
第二个轴的 索引为1的 大于5的元素 对应的 第一个轴的数据: tensor([[3, 8, 1, 8]])

# 5.创建两个形状为(3,4)的随机张量t1和t2，都转换形状为(4,3), 然后按0轴进行拼接，得到形状为(8,3)的张量，并打印。
import torch

# 创建两个形状为(3,4)的随机张量
t1 = torch.rand(3, 4)
t2 = torch.rand(3, 4)
print(f"t1: {t1}")
print(f"t2: {t2}")
# 转换形状为(4,3)
t1 = t1.reshape(4, 3)
t2 = t2.reshape(4, 3)

# 按0轴进行拼接
t3 = torch.cat([t1, t2], dim=0)
print(f"t3: {t3}")
print(f"t3.shape: {t3.shape}")

t1: tensor([[0.8463, 0.3997, 0.3458, 0.2899],
        [0.2253, 0.5289, 0.4712, 0.9801],
        [0.3612, 0.9313, 0.7176, 0.0849]])
t2: tensor([[0.1855, 0.1685, 0.6392, 0.5308],
        [0.1238, 0.4026, 0.0390, 0.1994],
        [0.1992, 0.9355, 0.3620, 0.9237]])
t3: tensor([[0.8463, 0.3997, 0.3458],
        [0.2899, 0.2253, 0.5289],
        [0.4712, 0.9801, 0.3612],
        [0.9313, 0.7176, 0.0849],
        [0.1855, 0.1685, 0.6392],
        [0.5308, 0.1238, 0.4026],
        [0.0390, 0.1994, 0.1992],
        [0.9355, 0.3620, 0.9237]])
t3.shape: torch.Size([8, 3])

# 6.创建一个形状为(3)的随机张量w，开启requires_grad, 计算loss = 0.5*w**2, 使用loss.mean().backward()获取梯度，并打印梯度。
import torch

# 创建一个形状为(3)的随机张量w，开启requires_grad
w = torch.randn(3, requires_grad=True)
print(f"w: {w}")
print(f"w.shape: {w.shape}")
print(f"w.grad: {w.grad}")
# 计算loss = 0.5*w**2
loss = 0.5 * w ** 2

# 使用loss.mean().backward()获取梯度
loss.mean().backward()

# 打印梯度
print(f"梯度: {w.grad}")

w: tensor([-0.7115,  1.2408, -0.7791], requires_grad=True)
w.shape: torch.Size([3])
w.grad: None
梯度: tensor([-0.2372,  0.4136, -0.2597])

day03

• 1.使用torch.randn创建形状为(3,4)的随机张量，开启梯度计算，使用detach()方法将张量转换为NumPy数组, 并打印。
• 2.修改pytorch模拟线性回归中的参数或设置，比如n_samples改为200，batch_size改为32，epochs改为200，学习率改为0.001，loss_fn改为MAE，并绘制训练过程中损失值的变化曲线。
• 3.绘制 prelu的激活函数图像 和 导数图像。
• 4.使用代码演示 二分类任务中，softmax和sigmoid函数的等价关系，比如原始输出的logits为：两个类别[1,3]，单个类别为[2],分别使用softmax和sigmoid计算正类别和负类别的概率，并打印。
• 5.创建一个线性层，输入维度3，输出维度5，权重初始化采用kaiming正态分布，偏置初始化采用全0初始化，并打印初始化的权重和偏置。

# 1.使用torch.randn创建形状为(3,4)的随机张量，开启梯度计算，使用detach()方法将张量转换为NumPy数组并打印出来。
import torch

# 创建形状为(3,4)的随机张量
t1 = torch.randn(3, 4, requires_grad=True)

# 将张量转换为NumPy数组并打印出来
t1_np = t1.detach().numpy()
print(f"t1_np: \n{t1_np}")

t1_np: 
[[-0.85907346  1.0835776  -0.8895768   0.00883052]
 [ 1.3591934   1.233448   -0.6031356   0.31076854]
 [ 0.17767143 -1.4833153   0.30477268  0.5143065 ]]

# 2.修改pytorch模拟线性回归中的参数或设置，比如n_samples改为500，batch_size改为32，epochs改为200，学习率改为0.001，loss_fn改为MAE，并绘制训练过程中损失值的变化曲线。

# 导入相关模块
import torch
# numpy对象 -> 张量 -> 数据集对象TensorDataset -> 数据加载器DataLoader
from torch.utils.data import TensorDataset  # 构造数据集对象
from torch.utils.data import DataLoader  # 数据加载器
from torch import nn  # nn模块中有平方损失函数和假设函数
from torch import optim  # optim模块中有优化器函数
from sklearn.datasets import make_regression  # 创建线性回归模型数据集
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

# 1.定义函数，创建线性回归数据
def create_dataset():
    # 创建数据集对象
    x, y, coef = make_regression(
        n_samples=200,          # 100条样本
        n_features=1,           # 1个特征
        noise=10,           # 噪声
        bias=13.9,            # 偏移
        coef=True,          # 是否返回系数
        random_state=6          #
    )

    # 封装成 张量
    x = torch.tensor(x, dtype=torch.float32)
    y = torch.tensor(y, dtype=torch.float32)

    # 返回结果
    return x, y, coef

# 2. 定义函数，用于模型训练
def train(x, y, coef):
    # 1. 构建DataLoader, tensor -> 数据集对象 -> 数据加载器
    dataset = TensorDataset(x, y)
    # 参数1：数据集对象，参数2：批次大小，参数3：是否打乱数据，训练集打乱，测试集不打乱，参数4：是否去掉最有一个不完整的批次
    dataloader = DataLoader(dataset, batch_size=32, shuffle=True, drop_last=False) # 100个样本，批次数16，6*16，4
    # 2. 创建模型，线性回归模型
    model = nn.Linear(1, 1)
    # 3. 创建 损失函数 和 优化器
    loss_fn = nn.MSELoss()
    optimizer = optim.SGD(model.parameters(), lr=1e-3)
    # 4.训练过程
    # 定义训练轮数
    epochs = 200
    # 记录 训练过程的 平均损失值
    total_train_loss_list = []
    # 遍历epoch
    for epoch in range(epochs):
        # 计算 每轮 的总的平均损失 和 总的样本数
        total_train_loss = 0
        total_train_sample = 0
        # 分 批次 训练
        for train_x, train_y in dataloader:
            # 前向传播，模型预测
            y_pred = model(train_x) # [batch_size, 1]
            # 计算损失值
            loss = loss_fn(y_pred, train_y.reshape(-1, 1))
            # 计算 总损失 和 总样本数
            batch_size = train_x.shape[0]
            total_train_loss += loss.item() * batch_size
            total_train_sample += batch_size
            # 梯度清零
            optimizer.zero_grad()
            # 反向传播，计算梯度
            loss.backward()
            # 更新模型参数
            optimizer.step()
        # 添加 本epoch 的平均损失 到 total_train_loss_list
        train_loss_mean = total_train_loss / total_train_sample
        total_train_loss_list.append(train_loss_mean)
        # print(f"epoch: {epoch}, 平均损失值: {train_loss_mean}")
    # 打印整个 训练损失记录
    # print(f"全部{epochs}轮的平均损失为：{total_train_loss_list}")
    print(f"模型参数：权重：{model.weight}, 偏置：{model.bias}")

    # 5. 可视化
    plt.figure(figsize=[15, 6])
    plt.subplot(1, 2, 1)
    # 绘制损失曲线
    plt.title("训练损失曲线")
    x_range = range(epochs)
    plt.plot(x_range, total_train_loss_list, label="train loss")
    # 添加网格
    plt.grid(True)
    # 添加X轴标签
    plt.xlabel("epoch")
    plt.ylabel("loss")
    # 添加曲线标签
    plt.legend()

    # 绘制预测值与真实值的对比图
    plt.subplot(1, 2, 2)
    plt.title('预测值和真实值的对比图')
    plt.scatter(x, y, label="真实数据点")
    # 计算真实的理论直线的y值
    y_true = [v*coef.item() + 13.8 for v in x]
    plt.plot(x, y_true, label="真实值")
    # 计算预测值
    # 关闭自动微分
    with torch.no_grad():
        y_pred = model(x).detach().numpy()
    # y_pred = [v*model.weight.item() + model.bias.item() for v in x]
    plt.plot(x, y_pred, label="预测值")
    # 添加网格
    plt.grid(True)
    # 添加X轴标签
    plt.xlabel("x")
    plt.ylabel("y")
    # 添加曲线标签
    plt.legend()
    plt.show()

# 测试
if __name__ == "__main__":
    x, y, coef = create_dataset()
    print(f"x.shape: {x.shape}, y.shape: {y.shape}")

    # 训练模型
    train(x, y, coef)

x.shape: torch.Size([200, 1]), y.shape: torch.Size([200])
模型参数：权重：Parameter containing:
tensor([[76.4290]], requires_grad=True), 偏置：Parameter containing:
tensor([13.7581], requires_grad=True)

# 3.绘制 prelu的激活函数图像 和 导数图像。

import torch
import matplotlib.pyplot as plt

# 1. 创建画布和坐标轴
fig, axes = plt.subplots(1, 2, figsize=(12, 5))

# -------------------------
# 第 1 个图：pReLU 函数本身
# -------------------------
x = torch.linspace(-10, 10, 1000)
a = torch.tensor([0.1])      # pReLU 的参数

y = torch.prelu(x, a)

axes[0].plot(x, y)
axes[0].set_title("pReLU 激活函数")
axes[0].grid()


# -------------------------
# 第 2 个图：pReLU 的导数
# -------------------------
x = torch.linspace(-10, 10, 1000, requires_grad=True)
a = torch.tensor([0.1])

y = torch.prelu(x, a)

# 求导
y.sum().backward()

axes[1].plot(x.detach(), x.grad)
axes[1].set_title("pReLU 激活函数导数")
axes[1].grid()

plt.tight_layout()
plt.show()

# 4.使用代码演示 二分类任务中，softmax和sigmoid函数的等价关系，比如原始输出的logits为：两个类别[1,3]，单个类别为[2],分别使用softmax和sigmoid计算正类别和负类别的概率，并打印。
import torch

logits = torch.tensor([[1, 3]], dtype=torch.float)
print(logits)

softmax = torch.softmax(logits, dim=1)
print(softmax)

logits = logits[:,1]-logits[:,0]
sigmoid = torch.sigmoid(logits)
print(sigmoid)

tensor([[1., 3.]])
tensor([[0.1192, 0.8808]])
tensor([0.8808])

# 5.创建一个线性层，输入维度3，输出维度5，权重初始化采用kaiming正态分布，偏置初始化采用全0初始化，并打印初始化的权重和偏置。
import torch
import torch.nn as nn
# 创建一个线性层，输入维度3，输出维度5
linear = nn.Linear(3, 5, bias=True)
# 对权重w 进行初始化
nn.init.kaiming_normal_(linear.weight)
# 对偏置b 进行初始化
nn.init.zeros_(linear.bias)
# 打印
print(linear.weight.data)
print(linear.bias.data)

tensor([[ 0.5717, -0.0778, -1.3657],
        [-0.3323,  0.0229, -1.3459],
        [-1.0581,  0.8332, -0.0232],
        [ 0.7131,  1.6377,  0.3035],
        [-0.8480,  0.7763,  0.2937]])
tensor([0., 0., 0., 0., 0.])

day04

• 1.搭建一个神经网络，有3个隐藏层和1个输出层，输入数据的输入特征维度为20，3个隐藏层的神经元数量分别为128，64，32，输出层的神经元数量为4。激活函数要求为：隐藏层使用relu激活函数，输出层使用softmax激活函数。并打印模型结构 和 模型参数。
• 2.使用代码演示 二分类任务中，分别使用 多分类交叉熵CrossEntropyLoss 和 二分类交叉熵BCELoss，比如原始输出的logits为：两个类别[[3,1], [4,3], [2,4]]，单个类别为[2,1,-2],分别计算对应的 多分类交叉熵损失值 和 二分类交叉熵损失值，并打印。
• 3.使用pytorch计算MSE损失值。已知 y_ture 为 [1, 2, 3, 4, 5, 6], y_pred 为 [2, 3, 4, 5, 6, 7]，计算MSE损失值，并打印。
• 4.使用梯度下降法，使用optim.SGD实现，循环迭代800次，求 loss = 0.5*w**2 + 10 的极小值点, 并打印loss最小值，以及loss是最小值时 w的值 和 梯度。
• 5.使用Adam优化器，使用optim.Adam实现，循环迭代800次，求 loss = 0.5*w**2 + 10 的极小值点, 并打印loss最小值，以及loss是最小值时 w的值 和 梯度。
• 6.使用AdamW优化器，使用optim.Adamw实现，循环迭代800次，求 loss = 0.5*w**2 + 10 的极小值点, 并打印loss最小值，以及loss是最小值时 w的值 和 梯度。

# 1.搭建一个神经网络，有3个隐藏层和1个输出层，输入数据的输入特征维度为20，3个隐藏层的神经元数量分别为128，64，32，输出层的神经元数量为4。
# 激活函数要求为：隐藏层使用relu激活函数，输出层使用softmax激活函数。并打印模型结构 和 模型参数。


# 导包
import torch
import torch.nn as nn
from torchsummary import summary  # 计算模型参数,查看模型结构 pip install torchsummary -i https://mirrors.aliyun.com/pypi/simple/

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 1.搭建神经网络
class ModelDemo(nn.Module):
    # 1.1 定义__init__方法，搭建网络层，并且进行参数初始化
    def __init__(self):
        # 初始化父类成员
        super().__init__()
        # 搭建网络层
        # 隐藏层1,输入特征数 20，输出特征数 128
        self.linear1 = nn.Linear(20, 128)
        # 隐藏层2，输入特征数 128，输出特征数 64
        self.linear2 = nn.Linear(128, 64)
        # 隐藏层3，输入特征数 64，输出特征数 32
        self.linear3 = nn.Linear(64, 32)
        # 输出层，输入特征数 32，输出特征数 4
        self.output = nn.Linear(32, 4)

        # 参数初始化
        # 初始化隐藏层1
        nn.init.xavier_normal_(self.linear1.weight)
        nn.init.zeros_(self.linear1.bias)
        # 初始化隐藏层2
        nn.init.kaiming_normal_(self.linear2.weight)
        nn.init.zeros_(self.linear2.bias)
        # 初始化输出层
        nn.init.xavier_normal_(self.output.weight)
        nn.init.zeros_(self.output.bias)

    # 1.2 定义forward方法，实现前向传播
    def forward(self, x):
        # 输入隐藏层1，加权求和 + 激活函数
        x = torch.relu(self.linear1(x))
        # 输入隐藏层2，加权求和 + 激活函数
        x = torch.relu(self.linear2(x))
        # 输入隐藏层3，加权求和 + 激活函数
        x = torch.relu(self.linear3(x))
        # 输入输出层，加权求和 + 激活函数
        x = torch.softmax(self.output(x), dim=-1)
        # 返回预测值
        return x

# 2.模型训练
def train():
    # 2.1 创建模型对象ModelDemo
    my_model = ModelDemo()
    print("查看模型结构：")
    print(my_model)

    # 2.2 创建数据集
    data = torch.randn(size=(10, 20))
    print(f"data: {data}")
    print(f"data.shape: {data.shape}")
    print(f"data.requires_grad: {data.requires_grad}")

    # 2.3 前向传播，模型预测
    output = my_model(data) # 底层自动调用forward方法, 执行前向传播
    print(f"output: {output}")
    print(f"output.shape: {output.shape}")
    print(f"output.requires_grad: {output.requires_grad}")
    print("-" * 60)

    # 2.4 计算 查看 模型参数
    print("计算模型参数：")
    # 参数1：模型对象；参数2：输入数据形状，10*20
    my_model.to(device)
    summary(my_model, input_size=(10, 20))
    print("查看模型参数：")
    for name,param in my_model.named_parameters():
        print(f"name: {name}")
        print(f"param: {param}")


# 3.测试
if __name__ == '__main__':
    train()

查看模型结构：
ModelDemo(
  (linear1): Linear(in_features=20, out_features=128, bias=True)
  (linear2): Linear(in_features=128, out_features=64, bias=True)
  (linear3): Linear(in_features=64, out_features=32, bias=True)
  (output): Linear(in_features=32, out_features=4, bias=True)
)
data: tensor([[ 0.7222, -0.0863,  0.5356,  0.6470,  0.4322,  0.4818, -0.7776,  0.4272,
          1.7723, -1.4479,  1.1387,  1.1514,  1.4133, -1.6729,  0.8887, -0.3169,
          0.6311, -0.9161,  0.7694,  0.9562],
        [-0.0066,  0.9702,  0.2877, -0.8346,  1.9843,  0.1039,  1.5156,  0.8568,
          0.8353,  1.1827,  0.4811, -0.4231,  0.0559, -0.3341, -2.3958, -0.5815,
          0.9180, -2.0646,  1.6093, -1.2262],
        [-0.7296,  0.9468, -0.3157,  0.6687,  1.7211, -1.7048,  0.1297,  0.8802,
         -0.4132, -0.7198, -0.3060,  0.9133,  2.1737,  1.0186, -1.9547, -0.6534,
          1.3868, -0.0124,  1.5287, -0.7931],
        [-1.4792,  1.4121,  1.4354, -1.7197, -0.6993, -0.1139, -0.9799,  0.3609,
          0.8258,  0.0564, -0.6916, -1.7462, -2.6413,  0.3140,  0.4434, -0.8825,
         -0.3473, -0.4817, -0.5086,  0.7418],
        [-0.9664, -1.3159, -0.5170,  0.0229, -2.3985,  1.1254,  1.3761, -0.6514,
         -0.7067, -0.3633, -0.9831, -1.1118,  0.5575, -0.4361,  1.2631,  0.3355,
         -0.2688,  0.0861, -1.6839,  1.8270],
        [ 1.3895,  1.5704,  0.7095, -0.2546, -0.0447,  1.2636, -0.1387, -1.1365,
         -0.1842,  0.0393,  0.1378,  0.3613,  0.7736, -0.9648, -0.0535, -0.3629,
         -0.5721,  1.1692, -0.6664, -1.0393],
        [ 1.0083, -0.1898, -0.1666, -0.7376, -1.0179, -2.1106,  1.4209, -0.5041,
          0.4916,  1.3665,  0.9918,  0.5540,  0.6099, -0.7724, -0.6299,  0.0195,
         -1.8812,  1.4333, -0.4333, -0.4589],
        [-0.9778, -0.2505, -0.2861, -1.2180,  0.1773,  1.2218, -0.1429, -2.0637,
         -0.5776,  1.1070,  1.2113,  1.5190, -0.4912, -0.5720,  0.4268,  0.0361,
         -0.0939, -0.3756,  1.2241,  0.5089],
        [-1.7184, -1.5688, -0.2747,  0.8946,  0.3975,  0.3351, -1.9165,  0.8653,
          1.3837,  0.6506,  1.6941,  0.4650,  2.4609, -1.2372,  0.7207,  0.1670,
          1.6150, -0.9680, -0.5443, -0.4207],
        [ 0.8018, -0.7720,  1.1704,  0.1219,  0.9244,  0.6195, -3.0844,  1.9890,
         -0.8557,  0.8801,  2.4049,  0.2876, -0.1910,  1.0796, -0.7060,  0.3741,
          1.9421,  0.9616,  0.2133,  0.9347]])
data.shape: torch.Size([10, 20])
data.requires_grad: False
output: tensor([[0.2306, 0.3313, 0.2732, 0.1649],
        [0.2333, 0.3103, 0.2911, 0.1653],
        [0.1898, 0.3517, 0.2753, 0.1832],
        [0.2292, 0.3664, 0.2637, 0.1408],
        [0.1914, 0.3519, 0.3073, 0.1494],
        [0.2339, 0.3018, 0.2789, 0.1854],
        [0.1594, 0.3846, 0.3095, 0.1465],
        [0.2339, 0.3517, 0.2739, 0.1405],
        [0.2374, 0.3553, 0.2432, 0.1641],
        [0.2689, 0.3402, 0.2550, 0.1359]], grad_fn=<SoftmaxBackward0>)
output.shape: torch.Size([10, 4])
output.requires_grad: True
------------------------------------------------------------
计算模型参数：
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Linear-1              [-1, 10, 128]           2,688
            Linear-2               [-1, 10, 64]           8,256
            Linear-3               [-1, 10, 32]           2,080
            Linear-4                [-1, 10, 4]             132
================================================================
Total params: 13,156
Trainable params: 13,156
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.02
Params size (MB): 0.05
Estimated Total Size (MB): 0.07
----------------------------------------------------------------
查看模型参数：
name: linear1.weight
param: Parameter containing:
tensor([[ 0.0970,  0.0855, -0.0611,  ...,  0.0448,  0.0180,  0.0465],
        [ 0.0419,  0.0806,  0.2274,  ...,  0.0700,  0.0055,  0.0337],
        [ 0.1548, -0.1215, -0.0058,  ..., -0.0043,  0.2355, -0.0220],
        ...,
        [-0.0980,  0.0343, -0.1124,  ...,  0.1626,  0.0046,  0.0468],
        [ 0.0029, -0.1358, -0.1149,  ..., -0.0369, -0.0391,  0.0790],
        [ 0.0543,  0.2061, -0.1433,  ...,  0.1157,  0.0934,  0.1384]],
       device='cuda:0', requires_grad=True)
name: linear1.bias
param: Parameter containing:
tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 0., 0., 0.], device='cuda:0', requires_grad=True)
name: linear2.weight
param: Parameter containing:
tensor([[-0.2266,  0.2350, -0.1647,  ...,  0.0821,  0.0954,  0.2066],
        [ 0.0241,  0.1515,  0.1049,  ..., -0.1931, -0.0177, -0.0244],
        [-0.0572, -0.1117,  0.0932,  ..., -0.0845,  0.0368, -0.1538],
        ...,
        [ 0.2678,  0.1597,  0.1124,  ...,  0.0255,  0.0058,  0.1341],
        [-0.1320,  0.2293,  0.2222,  ..., -0.2828,  0.1095, -0.0857],
        [ 0.0711, -0.0697,  0.0811,  ..., -0.0872, -0.1307,  0.1419]],
       device='cuda:0', requires_grad=True)
name: linear2.bias
param: Parameter containing:
tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       device='cuda:0', requires_grad=True)
name: linear3.weight
param: Parameter containing:
tensor([[ 0.1118,  0.0029, -0.1118,  ...,  0.0698, -0.1208, -0.0676],
        [-0.1060, -0.0712,  0.0464,  ...,  0.0650,  0.0687,  0.1015],
        [ 0.0430, -0.0873,  0.0759,  ..., -0.0639,  0.0143,  0.1047],
        ...,
        [-0.0564,  0.0564,  0.0747,  ..., -0.0459,  0.0229, -0.0639],
        [-0.0459,  0.0059, -0.0845,  ...,  0.1211,  0.0231, -0.1027],
        [-0.0260,  0.0935, -0.0812,  ...,  0.1056, -0.0500,  0.1228]],
       device='cuda:0', requires_grad=True)
name: linear3.bias
param: Parameter containing:
tensor([-0.0117,  0.1063,  0.0107, -0.0916, -0.0816,  0.1044, -0.0399, -0.0129,
        -0.0823,  0.1182, -0.1186,  0.0661,  0.0077, -0.0874,  0.0205, -0.0349,
        -0.0220,  0.0624,  0.1220,  0.0773,  0.1086,  0.0973,  0.0833,  0.0550,
         0.0207, -0.0176, -0.0507, -0.1212, -0.0415,  0.1025,  0.0176,  0.0105],
       device='cuda:0', requires_grad=True)
name: output.weight
param: Parameter containing:
tensor([[ 0.2973,  0.1266,  0.0873, -0.5482,  0.2228, -0.2754, -0.2585, -0.1005,
         -0.0771, -0.3397,  0.3239, -0.1660, -0.1010,  0.0278,  0.1315,  0.0336,
         -0.1121,  0.1414,  0.2368,  0.2339, -0.1915, -0.3699, -0.3244, -0.4605,
          0.1247, -0.1190,  0.0061,  0.3321,  0.1629,  0.2699, -0.1127,  0.5832],
        [ 0.1846, -0.2821, -0.1558, -0.2147, -0.0241,  0.2201,  0.0849,  0.1045,
         -0.0028,  0.2088,  0.0071, -0.1830, -0.0200, -0.0178, -0.0116,  0.1165,
          0.0257, -0.2384,  0.3226,  0.1483,  0.1442,  0.7120,  0.4201,  0.1805,
         -0.3795,  0.0289, -0.0815,  0.3679, -0.1334, -0.0531,  0.3140,  0.0128],
        [ 0.5472,  0.0324,  0.5694, -0.2798,  0.5592,  0.3089,  0.4404, -0.0490,
          0.2804, -0.1889, -0.1140,  0.0887, -0.0787,  0.3601,  0.2508, -0.0791,
          0.2545, -0.1007,  0.3294,  0.0665,  0.2633,  0.3503, -0.1244, -0.1213,
         -0.2067, -0.4668, -0.1748, -0.1859,  0.1820, -0.3398,  0.0034, -0.0975],
        [ 0.4904,  0.3744,  0.1387, -0.1629, -0.0548,  0.1310, -0.0254, -0.2700,
          0.0400, -0.1855,  0.2361, -0.0216,  0.1238, -0.0948, -0.2460, -0.3875,
         -0.0354, -0.0374, -0.4726, -0.4871,  0.0747,  0.1405,  0.3730,  0.5118,
          0.0252,  0.0100,  0.1564,  0.2469, -0.2971, -0.0988, -0.0510, -0.1716]],
       device='cuda:0', requires_grad=True)
name: output.bias
param: Parameter containing:
tensor([0., 0., 0., 0.], device='cuda:0', requires_grad=True)

# 2.使用代码演示 二分类任务中，分别使用 多分类交叉熵CrossEntropyLoss 和 二分类交叉熵BCELoss，
# 比如原始输出的logits为：两个类别[[3,1], [4,3]]，单个类别为[2,1],分别计算对应的 多分类交叉熵损失值 和 二分类交叉熵损失值，并打印。
import torch
import torch.nn as nn
# 定义函数，计算 多分类交叉熵损失值
def demo01():
    print("二分类任务使用多分类交叉熵损失")
    # 1. 创建 样本的真实类别
    y_true = torch.tensor([0, 0, 1])

    # 2.创建 模型预测 的原始输出logits值
    y_logits = torch.tensor([[3,6], [4,3], [2,4]], dtype=torch.float)

    # 3.创建 交叉熵损失函数
    loss_fn = nn.CrossEntropyLoss()

    # 4.计算损失
    loss = loss_fn(y_logits, y_true)
    print(f"loss: {loss}")
    # 5.计算预测概率
    y_pred = torch.softmax(y_logits, dim=-1)
    print(f"y_pred: {y_pred}")

# 定义函数，计算 二分类交叉熵损失值
def demo02():
    print("二分类任务使用二分类交叉熵损失")
    # 1. 创建 样本的真实类别
    y_true = torch.tensor([0, 0, 1], dtype=torch.float)

    # 2.创建 模型预测 的原始输出logits值
    y_logits = torch.tensor([3,-1,2], dtype=torch.float)
    # 经过sigmoid,转化为正类别的 概率
    y_pred = torch.sigmoid(y_logits)

    # 3.创建 交叉熵损失函数
    loss_fn = nn.BCELoss()

    # 4.计算损失
    loss = loss_fn(y_pred, y_true)
    print(f"loss: {loss}")
    print(f"y_pred: {y_pred}")

# 测试
if __name__ == '__main__':
    demo01()
    demo02()

二分类任务使用多分类交叉熵损失
loss: 1.1629257202148438
y_pred: tensor([[0.0474, 0.9526],
        [0.7311, 0.2689],
        [0.1192, 0.8808]])
二分类任务使用二分类交叉熵损失
loss: 1.1629258394241333
y_pred: tensor([0.9526, 0.2689, 0.8808])

# 2.使用代码演示 二分类任务中，分别使用 多分类交叉熵CrossEntropyLoss 和 二分类交叉熵BCELoss，
# 比如原始输出的logits为：两个类别[[3,1], [4,3]]，单个类别为[2,1],分别计算对应的 多分类交叉熵损失值 和 二分类交叉熵损失值，并打印。
import torch
import torch.nn as nn
# 定义函数，计算 多分类交叉熵损失值
def demo01():
    print("多分类交叉熵损失")
    # 1. 创建 样本的真实类别
    # y_true = torch.tensor([[0,0,1], [0,1,0]], dtype=torch.float)
    y_true = torch.tensor([0, 0, 1])

    # 2.创建 模型预测 的原始输出logits值
    y_logits = torch.tensor([[3,1], [4,3], [2,4]], dtype=torch.float)

    # 3.创建 交叉熵损失函数
    loss_fn = nn.CrossEntropyLoss()

    # 4.计算损失
    loss = loss_fn(y_logits, y_true)
    print(f"loss: {loss}")
    # 5.计算预测概率
    y_pred = torch.softmax(y_logits, dim=-1)
    print(f"y_pred: {y_pred}")

# 定义函数，计算 二分类交叉熵损失值
def demo02():
    print("二分类交叉熵损失")
    # 1. 创建 样本的真实类别
    y_true = torch.tensor([0,0,1], dtype=torch.float)

    # 2.创建 模型预测 的原始输出logits值
    y_logits = torch.tensor([-2,-1,2], dtype=torch.float)
    # 经过sigmoid,转化为正类别的 概率
    y_pred = torch.sigmoid(y_logits)

    # 3.创建 交叉熵损失函数
    loss_fn = nn.BCELoss()

    # 4.计算损失
    loss = loss_fn(y_pred, y_true)
    print(f"loss: {loss}")
    print(f"y_pred: {y_pred}")

# 测试
if __name__ == '__main__':
    demo01()
    demo02()

多分类交叉熵损失
loss: 0.18903924524784088
y_pred: tensor([[0.8808, 0.1192],
        [0.7311, 0.2689],
        [0.1192, 0.8808]])
二分类交叉熵损失
loss: 0.18903927505016327
y_pred: tensor([0.1192, 0.2689, 0.8808])

# 3.使用pytorch计算MSE损失值。已知 y_ture 为 [1, 2, 3, 4, 5, 6], y_pred 为 [2, 3, 4, 5, 6, 7]，计算MSE损失值，并打印。
import torch
import torch.nn as nn
# 获取真实值和预测值
y_true = torch.tensor([1, 2, 3, 4, 5, 6], dtype=torch.float)
y_pred = torch.tensor([2, 3, 4, 5, 6, 7], dtype=torch.float)
# 定义损失函数
loss_fn = nn.MSELoss()
# 计算损失值
loss = loss_fn(y_pred, y_true)

print(f"loss: {loss}")

loss: 1.0

# 4.使用梯度下降法，求 loss = 0.5*w**2 + 10 的极小值点 并打印loss最小值，以及loss是最小值时 w的值 和 梯度。
# 导包
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']  # 微软雅黑
plt.rcParams['axes.unicode_minus'] = False            # 解决负号显示问题
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

print("梯度下降法 —— sgd")
# 1.初始化模型参数w
w = torch.tensor([1.0], requires_grad=True, dtype=torch.float32)
# 2.求损失值
loss = 0.5*w**2 + 10   # w
# 3.创建优化器
# 参数1：待优化的模型参数列表，参数2：学习率
optimizer = optim.SGD([w], lr=0.01)
# 定义变量，记录损失值
loss_list = []
for i in range(800):
    # 4.计算损失值
    loss = 0.5 * (w ** 2)  # w
    # 5.计算梯度，梯度清零 + 反向传播 + 更新参数
    optimizer.zero_grad()   # 梯度清零
    loss.mean().backward()  # 反向传播
    optimizer.step()    # 更新参数
    loss_list.append(loss.mean().item())
    # print(f"第{i+1}次更新结果：w:{w}, w.grad: {w.grad}, loss: {loss}")
# 6.打印结果
print(f"最终结果：w:{w}, w.grad: {w.grad}, loss: {loss}")
# 7.绘制loss曲线
import matplotlib.pyplot as plt
plt.figure(figsize=(12,8))
plt.plot(range(len(loss_list)),loss_list)
plt.xlabel("迭代次数")
plt.ylabel("损失均值loss.mean")
plt.grid()
plt.show()

梯度下降法 —— sgd
最终结果：w:tensor([0.0003], requires_grad=True), w.grad: tensor([0.0003]), loss: tensor([5.2968e-08], grad_fn=<MulBackward0>)

# 5.使用Adam优化器，循环迭代800次，求 loss = 0.5*w**2 + 10 的极小值点, 并打印loss最小值，以及loss是最小值时 w的值 和 梯度。
# 导包
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']  # 微软雅黑
plt.rcParams['axes.unicode_minus'] = False            # 解决负号显示问题
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

print("梯度下降优化方法 —— adam")
# 1.初始化模型参数w
w = torch.tensor([1.0], requires_grad=True, dtype=torch.float32)
# 2.求损失值
loss = 0.5*w**2 + 10   # w
# 3.创建优化器
# 参数1：待优化的模型参数列表，参数2：学习率，参数3：衰减系数
optimizer = optim.Adam([w], lr=0.01, betas=(0.9, 0.999), weight_decay=1e-3)
# 定义变量，记录损失值
loss_list = []
for i in range(800):
    # 4.计算损失值
    loss = 0.5 * (w ** 2)  # w
    # 5.计算梯度，梯度清零 + 反向传播 + 更新参数
    optimizer.zero_grad()   # 梯度清零
    loss.mean().backward()  # 反向传播
    optimizer.step()    # 更新参数
    loss_list.append(loss.mean().item())
    # print(f"第{i+1}次更新结果：w:{w}, w.grad: {w.grad}, loss: {loss}")
# 6.打印结果
print(f"最终结果：w:{w}, w.grad: {w.grad}, loss: {loss}")
# 7.绘制loss曲线
import matplotlib.pyplot as plt
plt.figure(figsize=(12,8))
plt.plot(range(len(loss_list)),loss_list)
plt.xlabel("迭代次数")
plt.ylabel("损失均值loss.mean")
plt.grid()
plt.show()

梯度下降优化方法 —— adam
最终结果：w:tensor([-3.2689e-16], requires_grad=True), w.grad: tensor([-3.1520e-16]), loss: tensor([4.9676e-32], grad_fn=<MulBackward0>)

# 6.使用AdamW优化器，使用optim.Adamw实现，循环迭代800次，求 loss = 0.5*w**2 + 10 的极小值点, 并打印loss最小值，以及loss是最小值时 w的值 和 梯度。
# 导包
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']  # 微软雅黑
plt.rcParams['axes.unicode_minus'] = False            # 解决负号显示问题
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

print("梯度下降优化方法 —— adamW")
# 1.初始化模型参数w
w = torch.tensor([1.0], requires_grad=True, dtype=torch.float32)
# 2.求损失值
loss = 0.5*w**2 + 10   # w
# 3.创建优化器，基于SGD, 加入动量 momentum(动量参数)，就是动量法
# 参数1：待优化的模型参数列表，参数2：学习率，参数3：衰减系数
optimizer = optim.AdamW([w], lr=0.01, betas=(0.9, 0.999), weight_decay=1e-3)
# 定义变量，记录损失值
loss_list = []
for i in range(800):
    # 4.计算损失值
    loss = 0.5 * (w ** 2)  # w
    # 5.计算梯度，梯度清零 + 反向传播 + 更新参数
    optimizer.zero_grad()   # 梯度清零
    loss.mean().backward()  # 反向传播
    optimizer.step()    # 更新参数
    loss_list.append(loss.mean().item())
    # print(f"第{i+1}次更新结果：w:{w}, w.grad: {w.grad}, loss: {loss}")
# 6.打印结果
print(f"最终结果：w:{w}, w.grad: {w.grad}, loss: {loss}")
# 7.绘制loss曲线
import matplotlib.pyplot as plt
plt.figure(figsize=(12,8))
plt.plot(range(len(loss_list)),loss_list)
plt.xlabel("迭代次数")
plt.ylabel("损失均值loss.mean")
plt.grid()
plt.show()

梯度下降优化方法 —— adamW
最终结果：w:tensor([-3.3323e-16], requires_grad=True), w.grad: tensor([-3.2264e-16]), loss: tensor([5.2048e-32], grad_fn=<MulBackward0>)

day05

• 1.使用两层dropout处理数据。输入数据形状为(2,4),隐藏层形状为(4,20),后接dropout(p=0.5),输出层形状为(20,10),得到输出结果，并打印。注意通常输出层之后不加dropout
• 2.修改ANN手机价格分类案例代码。采用周期启动的余弦退火学习率调度策略torch.optim.lr_scheduler.CosineAnnealingWarmRestarts来调整学习率，训练模型，并打印最终的测试准确率。
• 3.修改ANN手机价格分类案例代码。模型中添加dropout层，优化器改为AdamW, 采用周期启动的余弦退火学习率调度策略torch.optim.lr_scheduler.CosineAnnealingWarmRestarts来调整学习率，训练模型，并打印最终的测试准确率。注意dropout的p应该小于0.1，因为数据集较小。

# 1.使用两层dropout处理数据。输入数据形状为(2,4),隐藏层形状为(4,20),后接dropout(p=0.5),输出层形状为(20,10),得到输出结果，并打印。注意通常输出层之后不加dropout

# 1.创建输入数据
t1 = torch.randint(0,10,size=(2,4))
# 转换为float类型
t1 = t1.to(dtype=torch.float32)
print(f"输入特征t1: {t1}")
# 2.搭建神经网络
class ModelDemo(nn.Module):
    # 1.1 定义__init__方法，搭建网络层，并且进行参数初始化
    def __init__(self):
        # 初始化父类成员
        super().__init__()
        # 搭建网络层
        # 隐藏层1
        self.linear1 = nn.Linear(4, 20)
        # 隐藏层2
        self.linear2 = nn.Linear(20, 10)
        # dropout层
        self.dropout = nn.Dropout(p=0.5)

    # 1.2 定义forward方法，实现前向传播
    def forward(self, x):
        # 输入隐藏层1，加权求和 + 激活函数
        x = torch.relu(self.linear1(x))
        # 输入dropout层，进行随机失活
        x = self.dropout(x)
        # 输入隐藏层2，加权求和 + 激活函数
        x = self.linear2(x)
        # 返回预测值
        return x

# 3.创建模型
model = ModelDemo()
# 前向传播，模型预测
y_pred = model(t1)
print(f"预测结果y_pred: {y_pred}")

输入特征t1: tensor([[6., 2., 6., 6.],
        [8., 5., 9., 0.]])
预测结果y_pred: tensor([[ 3.4134, -0.7866,  1.1466, -1.1044, -3.8304, -3.5764, -0.4554,  0.5703,
          2.6228, -1.6571],
        [ 3.2008, -0.6340,  1.3045, -2.6729, -6.2804,  0.1498,  1.3902, -3.3826,
          2.1994,  1.7634]], grad_fn=<AddmmBackward0>)

# 2.修改ANN手机价格分类案例代码。采用周期启动的余弦退火学习率调度策略torch.optim.lr_scheduler.CosineAnnealingWarmRestarts来调整学习率，训练模型，并打印最终的测试准确率。

import torch                                                # pytorch框架
from torch.utils.data import TensorDataset                  # 数据集对象
from torch.utils.data import DataLoader                     # 数据加载器
import torch.nn as nn                                       # 神经网络层的操作
import torch.optim as optim                                 # 优化器
from sklearn.model_selection import train_test_split        # 拆分 训练集 和 测试集
import matplotlib.pyplot as plt                             # 绘图
import numpy as np                                          # 数组操作
import pandas as pd                                         # 数据处理
import time                                                 # 时间模块

from torchsummary import summary
from sklearn.preprocessing import StandardScaler

device = "cuda" if torch.cuda.is_available() else "cpu"
# 1.准备数据集
def create_dataset():
    # 1.加载CSV数据集
    data = pd.read_csv("./data/手机价格预测.csv")
    # 2.获取特征x 和 标签y
    x = data.iloc[:, :-1]
    y = data.iloc[:, -1]
    # print(f"x: {x.head()}")
    # print(f"y: {y.head()}")
    # 3.特征列 转换为 float
    x = x.astype(np.float32)
    # print(f"x: {x}")

    # 4.拆分数据集
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=6, stratify=y)

    # 优化1：数据标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 5.把数据集转换为张量, numpy数组 -> 张量 -> 数据集对象TensorDataset -> 数据加载器DataLoader
    train_dataset = TensorDataset(torch.tensor(x_train), torch.tensor(y_train.values))
    test_dataset = TensorDataset(torch.tensor(x_test), torch.tensor(y_test.values))

    # 6.返回结果
    return train_dataset, test_dataset, x_train.shape[1], len(y_train.unique())

# 2.搭建神经网络
class PhonePriceClassifier(nn.Module):
    # 1.定义__init__方法, 初始化父类成员，搭建神经网络
    def __init__(self, input_dim, output_dim):
        # 初始化父类成员
        super().__init__()
        # 搭建神经网络
        # 优化2：增加网络深度
        self.linear1 = nn.Linear(input_dim, 128)
        self.linear2 = nn.Linear(128, 256)
        self.linear3 = nn.Linear(256, 512)
        self.linear4 = nn.Linear(512, 256)
        self.linear5 = nn.Linear(256, output_dim)
        pass
    # 2.定义forward方法，实现前向传播
    def forward(self, x):
        # 隐藏层1
        x = torch.relu(self.linear1(x))
        # 隐藏层2
        x = torch.relu(self.linear2(x))
        x = torch.relu(self.linear3(x))
        x = torch.relu(self.linear4(x))
        # 输出层
        x = self.linear5(x)
        # 返回结果
        return x

# 3.模型训练
def train(train_dataset, input_dim, output_dim):
    # 1.创建数据加载器DataLoader
    # 参数1：数据集对象；参数2：批量大小；参数3：是否打乱数据
    train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
    # 2.创建神经网络模型
    model = PhonePriceClassifier(input_dim, output_dim)
    model.to(device)
    # 3.定义损失函数
    loss_fn = nn.CrossEntropyLoss()
    # 4.创建优化器对象
    # 优化3：使用Adam优化方法
    optimizer = optim.Adam(model.parameters(), lr=1e-4)
    # 创建余弦退火学习率调度器
    scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=20, T_mult=1, eta_min=0)
    # 5.模型训练
    # 定义变量，记录 训练总轮数
    epochs = 100
    # 遍历轮数
    for epoch in range(epochs):
        # 记录 每次训练的 损失值，训练样本数
        total_loss = 0.
        total_sample = 0
        # 记录训练开始时间
        start_time = time.time()
        # 遍历批次
        for x, y in train_loader:
            # 训练模式
            model.train()
            # 移动数据到GPU
            x = x.to(device)
            y = y.to(device)
            # 前向传播
            y_pred = model(x)
            # 计算损失值
            loss = loss_fn(y_pred, y)
            # 更新总损失
            batch_size = x.shape[0]
            total_loss += loss.item()*batch_size
            # 更新总样本数
            total_sample += batch_size
            # 梯度清零
            optimizer.zero_grad()
            # 反向传播
            loss.backward()
            # 更新参数
            optimizer.step()
            # 调整学习率
            scheduler.step()

        # 打印训练信息
        # print(f"epoch: {epoch}, loss: {total_loss / total_sample}, time: {time.time() - start_time:.2f}")
        pass
    # 6.保存模型参数
    # print(f"\n\n模型的参数信息: {model.state_dict()}\n\n")
    torch.save(model.state_dict(), "./model/phone_price_classifier.pth")    # 模型文件，后缀名 .pth, .pkl, .pickle 均可
    pass

# 4.模型测试
@torch.no_grad()
def evaluate(test_dataset, input_dim, output_dim):
    # 1. 创建神经网络分类对象.
    model = PhonePriceClassifier(input_dim, output_dim)
    model.to(device)
    # 2.加载模型参数
    model.load_state_dict(torch.load('./model/phone_price_classifier.pth'))
    # 3.创建数据加载器DataLoader
    # 参数1：数据集对象；参数2：批量大小；参数3：是否打乱数据
    test_loader = DataLoader(test_dataset, batch_size=16, shuffle=False)
    # 4.记录正确样本的数量
    correct_sample = 0
    total_sample = 0
    # 5.开始测试, 遍历数据加载器的批次数据
    for x, y in test_loader:
        # 切换到测试模式
        model.eval()
        # 张量 迁移 到 GPU
        x = x.to(device)
        y = y.to(device)
        # 6.前向传播，模型预测
        y_pred = model(x)   # 形状(batch_size, 4), 每个类别的输出logits
        # print(f"预测结果y_pred：{y_pred}")
        # 7.计算预测正确的数量
        correct = y_pred.argmax(dim=1) == y
        correct_sample += correct.sum().item()
        total_sample += y.size(0)
    print(f"测试集准确率：{correct_sample / total_sample}")

# 5.测试
if __name__ == '__main__':
    # 1.准备数据集
    train_dataset, test_dataset, input_dim, output_dim = create_dataset()
    # 打印
    print(f"train_dataset: {train_dataset}")
    print(f"test_dataset: {test_dataset}")
    print(f"input_dim: {input_dim}")
    print(f"output_dim: {output_dim}")
    # 2.构建神经网络
    model = PhonePriceClassifier(input_dim, output_dim)
    # 3.统计模型参数
    model.to(device)
    # summary(model,input_size=(input_dim,))
    # 4.模型训练
    train(train_dataset, input_dim, output_dim)
    # 5.模型测试
    evaluate(test_dataset, input_dim, output_dim)
    pass

train_dataset: <torch.utils.data.dataset.TensorDataset object at 0x000001C733E1E710>
test_dataset: <torch.utils.data.dataset.TensorDataset object at 0x000001C733E1E990>
input_dim: 20
output_dim: 4
测试集准确率：0.9075

# 3.修改ANN手机价格分类案例代码。模型中添加dropout层，优化器改为AdamW, 采用周期启动的余弦退火学习率调度策略torch.optim.lr_scheduler.CosineAnnealingWarmRestarts来调整学习率，训练模型，并打印最终的测试准确率。注意dropout的p应该小于0.1，因为数据集较小。

import torch                                                # pytorch框架
from torch.utils.data import TensorDataset                  # 数据集对象
from torch.utils.data import DataLoader                     # 数据加载器
import torch.nn as nn                                       # 神经网络层的操作
import torch.optim as optim                                 # 优化器
from sklearn.model_selection import train_test_split        # 拆分 训练集 和 测试集
import matplotlib.pyplot as plt                             # 绘图
import numpy as np                                          # 数组操作
import pandas as pd                                         # 数据处理
import time                                                 # 时间模块

from torchsummary import summary
from sklearn.preprocessing import StandardScaler

device = "cuda" if torch.cuda.is_available() else "cpu"
# 1.准备数据集
def create_dataset():
    # 1.加载CSV数据集
    data = pd.read_csv("./data/手机价格预测.csv")
    # 2.获取特征x 和 标签y
    x = data.iloc[:, :-1]
    y = data.iloc[:, -1]
    # print(f"x: {x.head()}")
    # print(f"y: {y.head()}")
    # 3.特征列 转换为 float
    x = x.astype(np.float32)
    # print(f"x: {x}")

    # 4.拆分数据集
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=6, stratify=y)

    # 优化1：数据标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 5.把数据集转换为张量, numpy数组 -> 张量 -> 数据集对象TensorDataset -> 数据加载器DataLoader
    train_dataset = TensorDataset(torch.tensor(x_train), torch.tensor(y_train.values))
    test_dataset = TensorDataset(torch.tensor(x_test), torch.tensor(y_test.values))

    # 6.返回结果
    return train_dataset, test_dataset, x_train.shape[1], len(y_train.unique())

# 2.搭建神经网络
class PhonePriceClassifier(nn.Module):
    # 1.定义__init__方法, 初始化父类成员，搭建神经网络
    def __init__(self, input_dim, output_dim):
        # 初始化父类成员
        super().__init__()
        # 搭建神经网络
        # 优化2：增加网络深度
        self.linear1 = nn.Linear(input_dim, 128)
        self.linear2 = nn.Linear(128, 256)
        self.linear3 = nn.Linear(256, 512)
        self.linear4 = nn.Linear(512, 256)
        self.linear5 = nn.Linear(256, output_dim)
        # 添加dropout层
        self.dropout = nn.Dropout(0.05)
        pass
    # 2.定义forward方法，实现前向传播
    def forward(self, x):
        # 隐藏层1
        x = torch.relu(self.linear1(x))
        # x = self.dropout(x)
        # 隐藏层2
        x = torch.relu(self.linear2(x))
        # x = self.dropout(x)
        x = torch.relu(self.linear3(x))
        x = self.dropout(x)
        x = torch.relu(self.linear4(x))
        x = self.dropout(x)
        # 输出层
        x = self.linear5(x)
        # 返回结果
        return x

# 3.模型训练
def train(train_dataset, input_dim, output_dim):
    # 1.创建数据加载器DataLoader
    # 参数1：数据集对象；参数2：批量大小；参数3：是否打乱数据
    train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
    # 2.创建神经网络模型
    model = PhonePriceClassifier(input_dim, output_dim)
    model.to(device)
    # 3.定义损失函数
    loss_fn = nn.CrossEntropyLoss()
    # 4.创建优化器对象
    # 优化3：使用AdamW优化方法
    optimizer = optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4)
    # 创建余弦退火学习率调度器
    scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=20, T_mult=1, eta_min=0)
    # 5.模型训练
    # 定义变量，记录 训练总轮数
    epochs = 100
    # 遍历轮数
    for epoch in range(epochs):
        # 记录 每次训练的 损失值，训练样本数
        total_loss = 0.
        total_sample = 0
        # 记录训练开始时间
        start_time = time.time()
        # 遍历批次
        for x, y in train_loader:
            # 训练模式
            model.train()
            # 移动数据到GPU
            x = x.to(device)
            y = y.to(device)
            # 前向传播
            y_pred = model(x)
            # 计算损失值
            loss = loss_fn(y_pred, y)
            # 更新总损失
            batch_size = x.shape[0]
            total_loss += loss.item()*batch_size
            # 更新总样本数
            total_sample += batch_size
            # 梯度清零
            optimizer.zero_grad()
            # 反向传播
            loss.backward()
            # 更新参数
            optimizer.step()
            # 调整学习率
            scheduler.step()

        # 打印训练信息
        # print(f"epoch: {epoch}, loss: {total_loss / total_sample}, time: {time.time() - start_time:.2f}")
        pass
    # 6.保存模型参数
    # print(f"\n\n模型的参数信息: {model.state_dict()}\n\n")
    torch.save(model.state_dict(), "./model/phone_price_classifier.pth")    # 模型文件，后缀名 .pth, .pkl, .pickle 均可
    pass

# 4.模型测试
@torch.no_grad()
def evaluate(test_dataset, input_dim, output_dim):
    # 1. 创建神经网络分类对象.
    model = PhonePriceClassifier(input_dim, output_dim)
    model.to(device)
    # 2.加载模型参数
    model.load_state_dict(torch.load('./model/phone_price_classifier.pth'))
    # 3.创建数据加载器DataLoader
    # 参数1：数据集对象；参数2：批量大小；参数3：是否打乱数据
    test_loader = DataLoader(test_dataset, batch_size=16, shuffle=False)
    # 4.记录正确样本的数量
    correct_sample = 0
    total_sample = 0
    # 5.开始测试, 遍历数据加载器的批次数据
    for x, y in test_loader:
        # 切换到测试模式
        model.eval()
        # 张量 迁移 到 GPU
        x = x.to(device)
        y = y.to(device)
        # 6.前向传播，模型预测
        y_pred = model(x)   # 形状(batch_size, 4), 每个类别的输出logits
        # print(f"预测结果y_pred：{y_pred}")
        # 7.计算预测正确的数量
        correct = y_pred.argmax(dim=1) == y
        correct_sample += correct.sum().item()
        total_sample += y.size(0)
    print(f"测试集准确率：{correct_sample / total_sample}")

# 5.测试
if __name__ == '__main__':
    # 1.准备数据集
    train_dataset, test_dataset, input_dim, output_dim = create_dataset()
    # 打印
    print(f"train_dataset: {train_dataset}")
    print(f"test_dataset: {test_dataset}")
    print(f"input_dim: {input_dim}")
    print(f"output_dim: {output_dim}")
    # 2.构建神经网络
    model = PhonePriceClassifier(input_dim, output_dim)
    # 3.统计模型参数
    model.to(device)
    # summary(model,input_size=(input_dim,))
    # 4.模型训练
    train(train_dataset, input_dim, output_dim)
    # 5.模型测试
    evaluate(test_dataset, input_dim, output_dim)
    pass

train_dataset: <torch.utils.data.dataset.TensorDataset object at 0x000001A2506E42F0>
test_dataset: <torch.utils.data.dataset.TensorDataset object at 0x000001A250659310>
input_dim: 20
output_dim: 4
测试集准确率：0.92

day06

• 1.使用 matplotlib 绘制360✖360✖3的 全黑图 和 全白图，并打印。
• 2.使用 matplotlib 加载一张图片，然后通过Conv2d(3, 8, 3, 1, 1)卷积层，打印输出特征图的形状，并展示所有特征图。
• 3.使用 matplotlib 加载一张图片，然后通过Conv2d(3, 8, 5, 2, 0)卷积层，打印输出特征图的形状，并展示所有特征图。
• 4.使用 matplotlib 加载一张图片，然后通过MaxPool2d(2, 2, 0)池化层，打印输出特征图的形状，并展示所有特征图。
• 5.使用 matplotlib 加载一张图片，然后通过MaxPool2d(10, 10, 0)池化层，打印输出特征图的形状，并展示所有特征图。
• 6.动手实现CIFAR10图像分类任务，尝试修改模型或参数，看看模型性能如何。

# 1.使用 matplotlib 绘制360✖360✖3的 全黑图 和 全白图，并打印。
import matplotlib.pyplot as plt
import torch
# 创建全黑图
black_img = torch.zeros((360, 360, 3))
plt.imshow(black_img)
plt.tight_layout()
plt.show()

# 创建全白图
white_img = torch.ones((360, 360, 3))
plt.imshow(white_img)
plt.tight_layout()
plt.show()

# 2.使用 matplotlib 加载一个自己获取的图片，然后通过Conv2d(3, 8, 3, 1, 1)卷积层，打印输出特征图的形状，并展示所有特征图。
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 1.加载图片
img = plt.imread("./data/img.jpg")
print(f"img.shape: {img.shape}")

# 2.创建Conv2d(3, 8, 3, 1, 1)卷积层
conv = nn.Conv2d(3, 8, 3, 1, 1)

# 3.把图片形状从 HWC 转换为 CHW，因为卷积层要求输入的图片形状为CHW,思路：np数组 -> torch张量
img_tensor = torch.tensor(img, dtype=torch.float).permute(2, 0, 1)
print(f"img_tensor.shape: {img_tensor.shape}")
# 4.添加一个维度，表示批次N，卷积层要求输入图片形状为NCHW
img_tensor = img_tensor.unsqueeze(0)
print(f"img_tensor.shape: {img_tensor.shape}")
# 5.卷积层前向传播，得到输出特征图
out = conv(img_tensor)
# 6.打印输出特征图的形状
print(f"特征图形状out.shape: {out.shape}")
# 7.展示所有特征图
out = out.squeeze(0).detach()
print(f"out.shape: {out.shape}")
plt.figure(figsize=(10, 10))
for i in range(out.shape[0]):
    plt.subplot(4, 4, i+1)
    plt.imshow(out[i])
plt.show()

img.shape: (640, 640, 3)
img_tensor.shape: torch.Size([3, 640, 640])
img_tensor.shape: torch.Size([1, 3, 640, 640])
特征图形状out.shape: torch.Size([1, 8, 640, 640])
out.shape: torch.Size([8, 640, 640])

# 3.使用 matplotlib 加载一个自己获取的图片，然后通过Conv2d(3, 8, 5, 2, 0)卷积层，打印输出特征图的形状，并展示所有特征图。
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 1.加载图片
img = plt.imread("./data/img.jpg")
print(f"img.shape: {img.shape}")

# 2.创建Conv2d(3, 8, 5, 2, 0)卷积层
conv = nn.Conv2d(3, 8, 5, 2, 0)

# 3.把图片形状从 HWC 转换为 CHW，因为卷积层要求输入的图片形状为CHW,思路：np数组 -> torch张量
img_tensor = torch.tensor(img, dtype=torch.float).permute(2, 0, 1)
print(f"img_tensor.shape: {img_tensor.shape}")
# 4.添加一个维度，表示批次N，卷积层要求输入图片形状为NCHW
img_tensor = img_tensor.unsqueeze(0)
print(f"img_tensor.shape: {img_tensor.shape}")
# 5.卷积层前向传播，得到输出特征图
out = conv(img_tensor)
# 6.打印输出特征图的形状
print(f"特征图形状out.shape: {out.shape}")
# 7.展示所有特征图
out = out.squeeze(0).detach()
print(f"out.shape: {out.shape}")
plt.figure(figsize=(10, 10))
for i in range(out.shape[0]):
    plt.subplot(4, 4, i+1)
    plt.imshow(out[i])
plt.show()

img.shape: (640, 640, 3)
img_tensor.shape: torch.Size([3, 640, 640])
img_tensor.shape: torch.Size([1, 3, 640, 640])
特征图形状out.shape: torch.Size([1, 8, 318, 318])
out.shape: torch.Size([8, 318, 318])

# 4.使用 matplotlib 加载一个自己获取的图片，然后通过MaxPool2d(2, 2, 0)池化层，打印输出特征图的形状，并展示所有特征图。
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 1.加载图片
img = plt.imread("./data/img.jpg")
print(f"img.shape: {img.shape}")

# 2.创建MaxPool2d(2, 2, 0)池化层
pool = nn.MaxPool2d(2, 2, 0)

# 3.把图片形状从 HWC 转换为 CHW，因为卷积层要求输入的图片形状为CHW,思路：np数组 -> torch张量
img_tensor = torch.tensor(img, dtype=torch.float).permute(2, 0, 1)
print(f"img_tensor.shape: {img_tensor.shape}")
# 4.添加一个维度，表示批次N，卷积层要求输入图片形状为NCHW
img_tensor = img_tensor.unsqueeze(0)
print(f"img_tensor.shape: {img_tensor.shape}")
# 5.前向传播，得到输出特征图
out = pool(img_tensor)
# 6.打印输出特征图的形状
print(f"特征图形状out.shape: {out.shape}")
# 7.展示所有特征图
out = out.squeeze(0).detach()
print(f"out.shape: {out.shape}")
plt.figure(figsize=(10, 10))
for i in range(out.shape[0]):
    plt.subplot(1, 3, i+1)
    plt.imshow(out[i])
plt.show()
# 8.out转换CHW为HWC
out = out.permute(1, 2, 0)
out = out / 255.0
print(f"out.shape: {out.shape}")
plt.imshow(out)
plt.show()

img.shape: (640, 640, 3)
img_tensor.shape: torch.Size([3, 640, 640])
img_tensor.shape: torch.Size([1, 3, 640, 640])
特征图形状out.shape: torch.Size([1, 3, 320, 320])
out.shape: torch.Size([3, 320, 320])

out.shape: torch.Size([320, 320, 3])

# 5.使用 matplotlib 加载一个自己获取的图片，然后通过MaxPool2d(10, 10, 0)池化层，打印输出特征图的形状，并展示所有特征图。
import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 1.加载图片
img = plt.imread("./data/img.jpg")
print(f"img.shape: {img.shape}")

# 2.创建MaxPool2d(10, 10, 0)池化层
pool = nn.MaxPool2d(10, 10, 0)

# 3.把图片形状从 HWC 转换为 CHW，因为卷积层要求输入的图片形状为CHW,思路：np数组 -> torch张量
img_tensor = torch.tensor(img, dtype=torch.float).permute(2, 0, 1)
print(f"img_tensor.shape: {img_tensor.shape}")
# 4.添加一个维度，表示批次N，卷积层要求输入图片形状为NCHW
img_tensor = img_tensor.unsqueeze(0)
print(f"img_tensor.shape: {img_tensor.shape}")
# 5.前向传播，得到输出特征图
out = pool(img_tensor)
# 6.打印输出特征图的形状
print(f"特征图形状out.shape: {out.shape}")
# 7.展示所有特征图
out = out.squeeze(0).detach()
print(f"out.shape: {out.shape}")
plt.figure(figsize=(10, 10))
for i in range(out.shape[0]):
    plt.subplot(1, 3, i+1)
    plt.imshow(out[i])
plt.show()
# 8.out转换CHW为HWC
out = out.permute(1, 2, 0)
out = out / 255.0
print(f"out.shape: {out.shape}")
plt.imshow(out)
plt.show()

img.shape: (640, 640, 3)
img_tensor.shape: torch.Size([3, 640, 640])
img_tensor.shape: torch.Size([1, 3, 640, 640])
特征图形状out.shape: torch.Size([1, 3, 64, 64])
out.shape: torch.Size([3, 64, 64])

out.shape: torch.Size([64, 64, 3])

day07

• 1.使用 nn.Embedding 获取128维度的词向量，输入文本为"星星
  一颗两颗三颗四颗 连成线背著背默默许下心愿
  看远方的星如果听的见
  它一定实现它一定实现
  载著你 彷彿载著阳光
  不管到哪里都是晴天
  蝴蝶自在飞
  花也布满天
  一朵一朵因你而香
  试图让夕阳飞翔
  带领你我环绕大自然
  迎著风 开始共渡每一天
  手牵手
  一步两步三步四步望著天"，并打印。要求词表中的token按照词频从高到底排序。
• 2.尝试优化RNN文本生成案例，看看生成歌词的效果。比如修改词嵌入维度embedding_dim，修改批次数量batch_size，修改序列长度sequence_length，添加学习率调度等。

# 1.使用 nn.Embedding 获取128维度的词向量，输入文本为"星星
#  一颗两颗三颗四颗 连成线背著背默默许下心愿
#  看远方的星如果听的见
#  它一定实现它一定实现
#  载著你 彷彿载著阳光
#  不管到哪里都是晴天
#  蝴蝶自在飞
#  花也布满天
#  一朵一朵因你而香
#  试图让夕阳飞翔
#  带领你我环绕大自然
#  迎著风 开始共渡每一天
#  手牵手
#  一步两步三步四步望著天"，并打印。要求词表中的token按照词频从高到底排序。
import torch
import torch.nn as nn
import jieba
from collections import Counter

def demo01():
    text = '''
星星
 一颗两颗三颗四颗 连成线背著背默默许下心愿
 看远方的星如果听的见
 它一定实现它一定实现
 载著你 彷彿载著阳光
 不管到哪里都是晴天
 蝴蝶自在飞
 花也布满天
 一朵一朵因你而香
 试图让夕阳飞翔
 带领你我环绕大自然
 迎著风 开始共渡每一天
 手牵手
 一步两步三步四步望著天
'''

    # 2.使用jieba 进行分词
    words = jieba.lcut(text)
    print(f"词序列words: {words}")

    # === 按词频排序 ===
    word_freq = Counter(words)
    unique_words = [w for w, _ in word_freq.most_common()]
    print(f"按照词频排序后的unique_words: {unique_words}")

    # === 构建词表 ===
    vocab = {word: index for index, word in enumerate(unique_words)}
    print(f"vocab: {vocab}")

    # 4.创建词嵌入层
    embed = nn.Embedding(num_embeddings=len(vocab), embedding_dim=128)
    print(f"embed: {embed}")

    # 5.将每个词转换为词向量
    for word in words:
        idx = vocab[word]
        idx_tensor = torch.tensor([idx])
        word_vector = embed(idx_tensor)
        print(f"{idx}: {word}\t词向量: {word_vector.detach()}")

if __name__ == '__main__':
    demo01()

词序列words: ['\n', '星星', '\n', ' ', '一颗', '两颗', '三颗', '四颗', ' ', '连成线', '背著', '背', '默默', '许下', '心愿', '\n', ' ', '看', '远方', '的', '星', '如果', '听', '的', '见', '\n', ' ', '它', '一定', '实现', '它', '一定', '实现', '\n', ' ', '载著', '你', ' ', '彷', '彿', '载', '著', '阳光', '\n', ' ', '不管', '到', '哪里', '都', '是', '晴天', '\n', ' ', '蝴蝶', '自在', '飞', '\n', ' ', '花', '也', '布满', '天', '\n', ' ', '一朵', '一朵', '因', '你', '而', '香', '\n', ' ', '试图', '让', '夕阳', '飞翔', '\n', ' ', '带领', '你', '我', '环绕', '大自然', '\n', ' ', '迎著风', ' ', '开始', '共渡', '每', '一天', '\n', ' ', '手牵手', '\n', ' ', '一步', '两步', '三步', '四步', '望', '著天', '\n']
按照词频排序后的unique_words: [' ', '\n', '你', '的', '它', '一定', '实现', '一朵', '星星', '一颗', '两颗', '三颗', '四颗', '连成线', '背著', '背', '默默', '许下', '心愿', '看', '远方', '星', '如果', '听', '见', '载著', '彷', '彿', '载', '著', '阳光', '不管', '到', '哪里', '都', '是', '晴天', '蝴蝶', '自在', '飞', '花', '也', '布满', '天', '因', '而', '香', '试图', '让', '夕阳', '飞翔', '带领', '我', '环绕', '大自然', '迎著风', '开始', '共渡', '每', '一天', '手牵手', '一步', '两步', '三步', '四步', '望', '著天']
vocab: {' ': 0, '\n': 1, '你': 2, '的': 3, '它': 4, '一定': 5, '实现': 6, '一朵': 7, '星星': 8, '一颗': 9, '两颗': 10, '三颗': 11, '四颗': 12, '连成线': 13, '背著': 14, '背': 15, '默默': 16, '许下': 17, '心愿': 18, '看': 19, '远方': 20, '星': 21, '如果': 22, '听': 23, '见': 24, '载著': 25, '彷': 26, '彿': 27, '载': 28, '著': 29, '阳光': 30, '不管': 31, '到': 32, '哪里': 33, '都': 34, '是': 35, '晴天': 36, '蝴蝶': 37, '自在': 38, '飞': 39, '花': 40, '也': 41, '布满': 42, '天': 43, '因': 44, '而': 45, '香': 46, '试图': 47, '让': 48, '夕阳': 49, '飞翔': 50, '带领': 51, '我': 52, '环绕': 53, '大自然': 54, '迎著风': 55, '开始': 56, '共渡': 57, '每': 58, '一天': 59, '手牵手': 60, '一步': 61, '两步': 62, '三步': 63, '四步': 64, '望': 65, '著天': 66}
embed: Embedding(67, 128)
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
8: 星星   词向量: tensor([[ 0.1835,  0.4872, -0.9369, -1.3920,  1.5523,  1.4023, -0.8046,  0.3765,
          0.5342,  0.0189, -0.0990,  0.6168,  1.4651,  0.3475,  0.6838, -1.5251,
          1.0523,  0.1220,  0.0798,  0.0283,  1.6665,  0.8973, -0.3719, -0.2188,
          1.7416, -2.9042,  1.1965, -0.5555, -0.1711,  1.5246,  1.3031,  0.9790,
          0.4646,  0.8355, -0.6908, -0.3641,  0.3912, -0.7358,  0.3831,  2.1132,
          0.2264,  1.4131,  1.2979,  1.3129,  0.4895,  0.7551,  0.1144, -0.3902,
         -0.4115, -0.6710, -1.7081,  1.0087, -0.4943, -2.7130,  0.6042,  0.4462,
         -0.5541,  0.5180,  0.2259, -0.0657,  0.1277, -0.7363, -0.0821, -0.6322,
          1.5498, -1.4887, -0.6614, -0.1978,  0.4339, -0.2104, -0.9799,  1.6317,
          1.2892, -2.0543, -0.7570,  0.6127, -1.4891,  1.1725,  1.1340, -1.0580,
          1.7516,  0.3899,  0.4097,  0.7502, -0.4266, -1.2378, -1.1773,  1.0381,
          0.8003,  0.9402, -0.6176, -0.9990,  1.8417,  0.5616,  0.0824,  0.4689,
         -0.1857, -1.4487, -1.0235,  1.3938,  1.0608,  0.1206, -0.4064, -0.7393,
          0.1459,  0.2270, -1.8763, -1.0721, -0.1382, -1.0131, -0.3761, -0.7022,
         -0.6367,  0.6296, -0.1648, -1.4059, -0.1349,  1.0895, -0.1716,  0.1845,
          0.3640, -0.3664, -1.2385, -0.2331,  1.2419,  1.7809,  0.5578,  1.2833]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
9: 一颗   词向量: tensor([[-0.0952, -0.4625, -2.1070, -0.0037, -0.8910,  0.6835, -0.2864,  0.5136,
         -0.7912, -0.5482, -0.4416, -1.3080,  0.7276, -0.0275,  1.1303,  1.2569,
          0.7802,  0.0361, -0.5211, -1.5997,  1.3849, -1.5849, -1.0076, -2.0865,
          0.4133,  1.2842, -0.7531,  0.0661, -0.3880, -1.6827,  0.7954, -0.3109,
          1.0018,  0.0746,  0.3924, -1.8521,  1.0004, -0.5827, -0.7694,  0.4591,
          0.0626,  0.2473,  0.0056,  0.9459,  0.7252, -1.3239, -2.2854, -0.2967,
          0.9872, -0.2565,  1.5954, -1.6574,  0.9963, -2.0413, -1.1700,  0.3044,
         -0.6900, -0.8878,  1.7776,  0.6022, -0.9321,  1.1377,  1.1811, -0.9509,
         -0.7105,  0.1396, -1.5480,  0.2982, -0.4047,  2.2029,  1.0299,  0.6874,
          0.8834,  1.5306,  0.3635, -1.2961, -0.9731, -0.8142,  0.6423, -1.3030,
          0.4076,  0.3296, -1.0752,  1.5335,  2.0811, -0.9509,  0.0708, -2.4400,
          0.4917,  0.0704,  1.8784,  1.3073,  0.3118, -0.6245, -0.0804, -1.2101,
          0.3584,  0.2284,  0.1327,  0.2522,  0.0545,  0.2045, -1.3562, -1.0401,
          0.8476,  1.7826, -0.1080,  0.0579,  0.2105, -0.2579, -0.3626, -1.2293,
         -0.3020, -0.2536, -1.6700, -0.1959,  1.1102,  1.1040,  0.6529, -0.3119,
          0.7558, -0.6343, -0.4792, -0.2486, -0.3554,  0.2107,  1.0031, -0.6590]])
10: 两颗  词向量: tensor([[-0.4241,  0.3842, -1.0727, -1.4128,  1.4355,  1.1545, -0.2644, -0.7621,
          1.2800, -1.3823,  0.7247,  1.3148,  2.4522,  0.9155,  1.1893, -0.1881,
          1.0175, -0.6195, -1.1411,  1.4055, -0.8957,  1.6052, -1.0145,  0.0874,
         -0.7277, -0.1779, -1.6127, -1.1583,  0.0521,  0.1163,  0.0885, -0.6367,
         -1.4189, -0.3521,  0.2732,  0.6589, -0.9027,  1.0495, -0.0275,  0.2075,
         -1.0504, -2.8300,  0.7126,  1.5965, -0.6808,  1.3230,  0.2472, -1.0436,
         -0.8222, -0.2674, -0.1792,  1.3296,  0.3519, -0.3567, -1.7306,  0.8841,
         -0.4993,  0.6366,  0.3238,  1.7503,  0.4911, -1.3844, -0.9417,  1.1072,
          0.2915, -0.7031,  0.6059, -0.4484, -1.4499, -0.9167,  0.3285,  0.8220,
          0.4488,  0.7519, -0.5930, -1.3105,  0.5181, -0.3260,  0.8733, -1.1038,
         -0.1815,  0.2122, -0.8948,  0.6983,  0.4185, -0.5262,  0.4956, -0.7615,
          0.1492, -1.0103,  1.3746, -2.0112,  0.7675, -0.2039,  2.6824, -0.0474,
         -0.2814,  1.3921, -0.7379, -1.7518,  2.1407,  0.6210,  0.5455,  1.8880,
          0.4104,  0.0215, -0.3853, -0.3236,  0.6369,  1.2165, -0.4176, -0.7624,
          0.2078,  0.1622, -0.3580,  1.1864,  0.9641,  0.5357, -1.4547, -0.3602,
          0.0064, -0.3495, -0.1450,  1.7285, -0.8818, -0.1155, -0.6609,  0.4982]])
11: 三颗  词向量: tensor([[ 1.1972,  0.3026,  0.6861, -1.4936,  1.1214,  1.1350,  0.2260, -0.0322,
          0.8376, -2.1491,  0.9146,  0.1889, -1.4430, -0.4548,  0.7127, -0.9101,
         -0.8638,  0.3050, -0.8244,  0.2154,  0.1484,  1.4157, -0.6944, -0.0055,
          0.7060, -0.3078,  0.2376,  0.6826,  2.1443, -0.2376,  0.0289,  2.0716,
          0.2080, -0.2745, -0.5286, -0.0173,  0.7995, -0.2597,  0.1030, -0.9618,
          0.3836, -0.2703,  0.8932, -1.3908,  0.3540,  0.7494,  1.9005,  0.7303,
         -1.6385,  0.7400, -0.2965,  0.6675,  0.3963,  0.1274,  1.8464,  1.7222,
         -1.1801,  1.0254, -0.8271,  0.0415, -0.4320,  0.8026, -0.0814, -0.7572,
         -1.5163,  0.9426, -1.1508, -1.6043,  0.9627, -0.4874,  1.8824,  0.3738,
         -0.9084, -0.7828,  1.7626,  0.0361, -1.0051, -0.1684, -1.7264,  0.5657,
         -0.1280,  1.4076,  0.4904, -0.8532, -0.4779, -1.0025,  0.6173, -0.5496,
          0.9116,  0.2816,  0.1610, -0.4029,  1.1215, -1.1204,  0.2299,  0.0634,
          0.0428, -0.0110,  0.1010, -1.2060, -1.2150, -0.0319,  1.2655, -0.8516,
          0.9262,  0.9088,  0.7849, -1.6405, -1.9032, -1.6078,  0.8318, -0.9396,
          0.6116, -2.6312, -0.0104,  1.2789,  0.3844, -0.8725, -0.8324,  1.2025,
          2.0355, -0.9117,  1.4998,  0.4595, -0.2576, -0.6752,  0.7153, -1.2831]])
12: 四颗  词向量: tensor([[ 2.2653, -0.0990, -0.4151,  1.7691,  0.0125,  0.0868, -0.2665,  0.1249,
          0.6308, -1.0945, -0.7040,  0.4018,  0.6617, -1.7021, -1.4128,  0.5096,
         -0.8145,  0.7628, -0.0089, -0.4675,  1.6505,  1.2618,  0.2549,  0.3889,
         -0.7146,  0.3026,  0.8814, -0.1159,  0.1816, -0.8549, -1.1286, -0.2564,
          3.1843,  0.2464, -0.9187,  0.9241,  0.1091,  0.1357,  0.4793, -1.6307,
         -0.3821, -0.7562,  0.6073, -0.0850,  1.6427,  0.4002, -0.8012,  0.2096,
         -1.5070,  1.4767, -0.6066,  0.9431, -1.7317,  0.0050, -2.2413, -1.9389,
         -1.3615,  0.5443,  0.3790, -1.5023, -0.9213, -0.4121,  1.5587, -0.0514,
          0.0400,  0.8381, -0.6121, -1.7556,  0.9796,  0.4298,  0.4889, -0.6758,
         -0.6474,  0.1093, -0.7632, -0.2690, -1.3831,  1.3360, -0.9560,  0.4525,
          0.2931,  1.3745, -0.2168,  0.3472,  1.0812,  0.1240, -0.0416,  1.7732,
         -0.3745, -2.5600, -0.4112, -0.2439, -0.6894,  0.1595,  0.2341,  0.7727,
         -0.7041,  1.1107,  0.2782,  0.1178, -0.4656, -1.3687, -0.0236, -0.6206,
          0.6577,  0.4913,  0.6707, -0.2326,  0.4894, -1.6483,  0.4459, -0.8915,
          0.1402,  1.6414, -0.6836,  0.7385, -2.5696, -1.5428,  0.3977, -0.5403,
          0.9011, -0.9073, -0.3712,  0.4510,  0.0162,  0.2468, -0.1403, -0.1803]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
13: 连成线 词向量: tensor([[-1.0089,  1.9068,  0.1027,  2.6734, -0.5348, -0.6113,  0.1489,  0.8982,
          1.1933, -0.9432,  1.3036, -0.6435, -0.5043, -0.2422,  2.4747,  0.7518,
          0.5725,  1.8265,  0.7251, -0.3818,  0.4764, -0.6340, -1.4265,  0.4799,
         -0.4832,  0.0947,  1.5408,  0.5760,  0.7311, -1.2044, -0.2357, -1.4807,
          1.8719, -1.8763,  0.5489,  0.6711, -0.1352, -0.2332, -1.1570, -0.4624,
          1.1595,  1.5324,  0.9102,  0.7717,  0.0449,  0.4176, -0.5125,  1.6061,
         -1.4227, -1.1869, -1.2770,  0.3141, -0.3876, -0.2360, -0.3205,  0.4684,
          0.5411,  1.0962, -2.0393, -0.1298,  0.4447, -1.0904, -1.3099,  0.7801,
          0.2982, -0.9387, -0.0730, -0.7430, -0.5198,  0.8293,  0.2138,  0.1790,
          0.9236,  0.9367, -0.0730, -0.5329,  0.1728,  0.0316, -0.3757, -2.4010,
         -2.8439,  0.8637,  1.6214,  1.0395, -0.6404, -1.1814, -0.3843,  1.4762,
          0.5888,  0.0333, -1.2155,  0.7936, -0.9066, -1.1480, -1.2870,  0.5459,
         -0.2048, -0.5562,  0.6448, -0.8447,  0.9164, -3.3514, -1.1823,  1.2056,
         -0.8367,  1.2647, -1.4880, -1.6201, -0.2069, -0.0443,  1.3610,  2.5970,
          1.5484,  0.0419,  0.3360, -0.1804, -1.3359,  0.9980, -1.1611, -0.7898,
          0.6173, -2.0333, -1.6544, -0.7136,  0.0444, -1.3843,  1.0230,  0.1293]])
14: 背著  词向量: tensor([[ 0.7876,  2.1792,  2.2059,  0.3068,  1.0159,  0.2849, -0.4607,  2.0255,
          0.1264, -1.1946,  0.7437,  0.3287,  0.5098, -0.6641, -1.1045, -1.6229,
         -0.6425, -0.0654, -2.1731, -0.0184, -1.2673, -0.7136,  0.9171, -1.4792,
         -0.0204, -0.2011,  1.3700,  0.8129,  0.8334, -0.6800, -1.3692,  0.0295,
          2.7637,  0.8466, -0.2823, -0.0622, -0.5180, -0.2318,  0.9640,  0.7181,
          0.5606, -0.2445, -0.6748, -0.0374, -0.4695,  1.4243, -1.4139,  0.1825,
         -0.1100,  0.0981, -1.6561, -2.0866, -1.4798, -0.4042,  1.6569, -0.2554,
          1.3079, -0.2598, -1.4106, -1.6662,  1.0674,  0.5720, -0.1954, -0.6007,
          0.8412, -0.8076, -1.1911,  0.8255,  0.9852, -1.8515,  0.1371,  1.5273,
          1.4887,  0.1104, -1.1449, -0.4188, -1.0321, -0.2365,  1.0290, -1.3560,
          0.4288,  2.0059,  0.1673,  1.2921, -0.3048,  1.0754, -0.3310, -1.8982,
         -1.1110,  1.3395, -0.6198, -1.3844, -0.2225, -0.3677, -0.0481, -0.0558,
         -0.2748, -2.0517,  0.7060,  0.7633, -1.7125,  0.1903,  0.2197, -0.2919,
          0.8530,  0.9545,  1.1665, -0.2727, -1.2817, -0.1791,  0.7877, -0.4660,
         -1.0399, -0.3832,  0.6765, -0.9848,  0.7830, -0.1709, -0.1176, -0.3470,
          0.0316, -0.0032, -0.6891,  0.3376,  0.9826,  0.9525,  0.7986, -0.1708]])
15: 背   词向量: tensor([[ 2.3734e-01,  1.2708e+00,  2.5140e-01,  1.2089e-01, -1.5100e-02,
          5.2751e-01,  5.9030e-01,  1.4860e+00,  1.3934e+00,  3.5726e-01,
          9.1020e-01, -2.2218e+00,  3.7391e-01,  9.5507e-01, -4.4845e-01,
          2.5683e-01,  2.3311e+00, -1.0414e+00,  1.3710e+00,  4.8989e-01,
         -1.2335e+00, -6.0398e-01, -3.6508e-01, -9.8114e-01,  8.4317e-01,
          4.8411e-02,  1.4439e+00,  4.6530e-02,  1.6278e-01, -4.2410e-01,
          4.2322e-01, -1.2813e-01, -1.2249e+00,  3.5543e-01,  5.3040e-01,
          1.9645e+00, -5.2517e-01, -9.5649e-01, -6.0416e-01,  1.7216e+00,
          2.0524e-01, -1.1140e+00,  5.7797e-01,  2.4478e-01,  1.1673e+00,
         -1.8646e+00, -4.1053e-01,  1.3479e+00,  1.4761e+00, -5.1711e-01,
          7.3766e-02,  2.0067e-01,  3.1754e-01,  9.2665e-01,  2.1854e+00,
          3.1614e-01, -2.8709e-02,  2.2981e-01, -4.9327e-01,  8.8275e-01,
         -6.8942e-01,  4.4588e-01, -3.0888e-01, -7.8357e-01, -6.0020e-01,
          1.0101e-01,  8.9447e-01, -8.2727e-01,  1.0017e+00,  6.5177e-01,
          2.0916e+00, -3.2217e-01,  7.6594e-01, -1.0357e+00,  1.4412e-01,
         -2.2681e-01,  3.1293e-01, -4.7175e-01, -6.6384e-01, -1.2676e+00,
          5.0739e-01,  1.6433e-01, -3.1845e-01, -6.0663e-01,  1.4500e+00,
          8.3583e-01, -1.9677e+00,  8.0365e-02,  4.8449e-01, -2.3415e-01,
          1.5498e+00, -1.0268e+00, -1.1252e+00, -3.6096e-01, -9.8169e-02,
         -1.1103e+00,  2.4518e+00, -2.9703e-04, -4.7274e-01,  4.6164e-01,
          1.3386e+00, -1.0836e+00,  6.7105e-01,  1.0665e+00, -1.0827e+00,
          1.3817e+00, -4.3349e-01,  5.8398e-01,  6.0266e-01,  4.5929e-01,
          1.4923e+00,  1.8565e-01, -5.4926e-01,  7.7824e-02, -5.4307e-01,
          8.9839e-01, -5.7604e-01, -1.0120e+00, -5.1401e-02, -4.5502e-01,
          1.9257e+00,  3.5499e-01,  3.3945e-01,  1.1403e-01, -5.6473e-01,
          2.9557e-01, -2.5702e-01, -1.4799e+00]])
16: 默默  词向量: tensor([[ 0.5855,  0.5649,  1.2516, -1.0654,  0.0194,  0.7558, -0.9596, -1.8844,
         -0.8768, -0.9258,  0.7908, -1.4043, -1.2133, -0.8897,  1.1674,  0.4095,
          0.2884, -0.2062, -0.3164,  1.5688, -0.8875, -0.3280, -0.7993,  1.1081,
          1.7414,  2.3032,  0.4477,  0.3683,  1.3404,  0.5538, -0.3748, -0.9234,
         -1.6365, -1.1173,  0.8437,  1.5516, -0.8803,  0.3150,  0.1510,  0.6790,
          0.1267,  3.1082, -2.0576, -1.5079,  0.7249, -0.5747, -0.8275, -0.2894,
          0.7550,  0.3751, -1.0428,  1.2397, -0.3644, -0.0388, -0.5385,  0.3079,
          0.0749,  0.1902,  1.7752,  0.2350, -0.8458, -0.2173, -1.0261,  0.1243,
          1.8935, -0.6879,  0.2402,  0.1903, -0.2396,  0.2941,  3.3073, -0.3757,
         -1.8381,  2.1608,  0.0395,  0.5703,  0.6058, -0.2424,  0.0935, -1.1924,
         -1.1714,  0.1079,  0.0437, -0.7684,  0.2372,  0.8401,  0.0348,  0.0776,
          1.7754, -1.3459,  1.0290, -1.6607, -0.8305, -0.9023, -1.0465, -0.9252,
         -0.6129, -0.5499, -1.0712,  0.5483,  2.3140, -0.7705, -1.3616, -0.4511,
          1.5649,  0.0098, -1.5093, -0.7352,  0.0066, -1.0004, -0.2411,  0.5052,
          1.9473,  0.1918,  0.3365, -0.0226,  0.9867, -0.8436, -1.3735, -0.8803,
         -0.9717, -0.7108, -1.7845, -1.5892, -1.1767, -1.5818, -1.2533,  0.3954]])
17: 许下  词向量: tensor([[-1.9168e+00,  4.8427e-01,  1.6830e+00,  1.7918e+00,  1.2230e+00,
          2.1999e-01, -5.0684e-01,  1.4321e+00, -6.7233e-01,  8.0671e-01,
         -4.4662e-02,  1.6716e+00, -1.0406e+00, -2.6862e-01,  9.4382e-01,
         -6.5747e-02,  1.6865e+00, -2.2126e-02,  7.2788e-02,  9.4403e-01,
         -2.3236e+00, -1.3564e-02,  1.4283e+00, -1.2860e+00, -5.1389e-01,
          1.6175e+00,  1.0914e+00, -1.1820e+00, -1.4320e+00, -4.6109e-02,
         -9.6742e-01,  2.1611e+00, -5.6264e-01, -1.1565e+00,  1.9390e-01,
          9.2234e-01,  1.0021e-02, -6.5935e-01, -8.2297e-01, -5.2027e-01,
         -1.2664e+00, -7.5104e-01,  3.7712e-01, -1.0337e+00,  2.1133e-01,
          1.1996e-01,  1.7219e-01, -4.2914e-01, -7.7655e-01, -1.2369e+00,
          1.4316e+00,  5.9886e-01,  2.7075e-01, -1.0055e+00, -4.1905e-01,
          2.0641e-01,  1.0546e+00, -1.0288e+00, -4.2799e-01,  1.7075e+00,
          3.4562e-01, -6.3579e-01,  1.8177e+00, -3.1740e-01,  1.3355e+00,
          8.3655e-01, -1.2970e-01, -5.6623e-01,  1.3618e+00, -8.1217e-01,
         -5.9931e-01,  1.7257e+00, -1.7200e+00, -2.0489e-01,  1.8407e+00,
          1.9718e-01,  5.7118e-01,  1.6514e+00,  1.3401e+00, -1.3435e+00,
         -4.0144e-01, -1.0155e-01, -1.1944e+00, -4.5984e-02,  6.7646e-01,
         -4.0648e-01,  5.7433e-01, -1.1582e+00,  2.7859e-01, -1.0964e+00,
         -1.3926e+00, -7.5777e-01, -2.0582e+00,  2.8480e-01, -1.1150e-01,
         -1.1630e+00, -1.2977e+00, -1.3570e+00, -9.2553e-01, -2.9389e-01,
         -8.6199e-01,  6.0487e-01, -7.3591e-01,  8.8837e-01,  2.7932e+00,
         -2.0715e-01,  4.4492e-01, -1.5744e-01, -1.2521e+00,  2.5512e-01,
          2.5749e-03,  1.0270e+00,  1.4577e+00,  1.2816e+00,  1.1000e+00,
          8.1408e-01, -8.5781e-01,  3.9352e-01, -1.1353e+00, -6.6646e-01,
         -2.3900e-01, -8.6223e-01,  1.4470e+00,  1.7640e-01,  2.9097e-01,
          4.9116e-01, -1.0895e-02,  7.6424e-01]])
18: 心愿  词向量: tensor([[-0.2722,  1.5364, -1.3689, -1.7894, -1.6638, -1.2606,  1.5057, -0.3066,
          0.2299,  0.3172, -0.1636, -0.5218,  0.6939, -2.5031,  0.8794, -0.3524,
          0.6943, -0.2636, -0.0768, -0.4456,  0.7122, -0.2961,  0.5403,  0.9556,
          0.6172,  0.1403,  1.6154, -0.6350,  1.7847,  0.2646, -0.6640, -0.1668,
          2.0648,  0.0089,  0.3429, -2.2141,  1.8766, -1.4421,  1.6883,  1.8436,
         -0.7833, -0.5841,  0.2226,  0.1777, -1.4001, -1.2400, -1.3822,  2.6764,
          0.8447, -0.4104, -0.4826,  0.9347,  0.0041,  0.4420,  0.2884,  0.1651,
         -0.0656,  1.5672,  0.7912, -0.1630, -0.6801,  0.9197, -0.2025, -0.5427,
          0.8947, -1.0273,  1.2590, -1.7895,  0.1924, -0.7166,  1.5944,  0.2242,
         -0.9353,  0.1765,  0.9089, -0.6721, -0.5409, -1.2609, -0.5078, -0.2503,
          0.1845,  1.0438, -0.0463, -1.0236,  0.0978, -0.9157, -0.8683, -0.0148,
         -1.1952,  2.4714, -0.2442, -1.3386, -1.5403, -1.3036, -1.4829, -0.6095,
         -0.5726, -1.0416, -0.3513,  0.3971,  1.3704,  0.0423, -0.5206, -1.7684,
         -0.7518, -0.4393,  0.4668,  0.5841, -1.1916, -1.0110,  0.6833, -1.2590,
         -0.7883,  1.3484,  0.1021, -0.1271,  0.3129, -0.0804, -1.5882, -0.8672,
          0.3482,  1.3307,  0.1446,  0.0331, -1.0778, -0.1092, -1.1599, -0.4233]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
19: 看   词向量: tensor([[-1.6378,  1.1989, -0.6366,  0.0372,  2.0751,  1.3119,  0.4727,  1.2676,
         -0.3800,  0.3326, -0.7496, -0.7480, -0.0793, -0.6415, -1.0095,  0.9856,
          0.5956, -0.5635, -0.7542,  0.3592,  0.9146, -0.2246, -1.1856, -0.9349,
         -0.1095, -0.8371,  0.9123, -1.0214, -0.7292,  0.4273,  1.1791, -0.6683,
         -1.8901, -0.2477, -0.1068, -0.7313,  0.4921, -0.0978,  0.1945,  0.4086,
         -0.3137,  0.2452, -0.8536, -0.2235, -0.6163,  0.8495,  1.2052, -0.4979,
         -1.2943,  0.4710, -0.2844, -0.5532, -1.4932,  0.7001, -0.1473, -0.9754,
          1.8101, -0.0287,  0.6692, -0.6750,  0.6471,  1.9667,  0.2542,  1.1195,
         -0.7262, -0.3463, -0.2518, -2.9235,  0.7129,  0.8904,  0.2089,  1.8507,
         -0.0445, -0.3453,  0.6186, -0.1506,  0.5771,  0.2950, -1.2261, -1.7731,
          0.2479,  0.3745,  0.0143, -0.4963,  0.4838, -0.1708, -1.1928, -0.1565,
         -0.4288, -1.4751,  1.0072,  1.3855,  1.6219,  1.7316, -0.4740, -0.4865,
         -0.5089,  0.2501,  0.6099, -0.2189, -0.0841, -0.9087,  0.6845,  0.1901,
          0.0069,  2.8011, -1.9380,  0.2300, -1.2650,  0.9575,  0.0194, -0.1019,
         -0.6718, -0.7557,  1.0150,  0.5572,  0.0731,  0.0102,  1.2525, -0.9054,
          0.4344,  0.5597,  0.6715, -0.4902,  0.1535, -0.7845, -0.7937, -1.4195]])
20: 远方  词向量: tensor([[-2.2151e-01,  2.7015e-01, -2.5084e-01, -4.4097e-01, -1.2715e+00,
         -2.9254e-01,  6.1142e-01, -1.9627e+00,  5.2096e-01,  1.2656e-01,
         -1.3257e+00,  3.0418e-01,  3.0586e-02, -1.2778e+00, -8.1623e-04,
          7.6972e-01,  4.1588e-01, -9.7389e-01,  6.3766e-01, -7.4420e-03,
          3.2223e-01,  6.0338e-02,  7.8877e-04,  6.7707e-02,  1.1984e+00,
          4.5039e-01,  5.3452e-01, -3.4807e-02,  1.5357e+00,  3.0241e-01,
          3.5626e-01, -4.7850e-01, -3.9241e-01, -5.7744e-01,  6.6992e-01,
          8.0270e-01,  3.1736e-01,  9.4924e-01,  5.7952e-01, -6.4206e-01,
          1.0187e+00, -2.1815e+00, -8.4608e-01,  1.6100e+00,  1.7417e+00,
         -7.7409e-01, -1.0568e+00,  1.0163e+00, -1.8650e+00, -7.5423e-01,
          1.7711e-01,  1.1056e+00, -5.5982e-01,  2.5708e-01, -1.1924e+00,
          5.4293e-01,  1.2407e+00,  1.0870e-02, -1.0442e+00,  2.4535e-01,
         -3.9359e-01, -5.6523e-01,  6.7341e-02,  7.0170e-01, -9.0430e-01,
         -2.1122e-01,  3.7679e-01, -3.6847e-01, -1.1514e+00,  3.1001e-01,
         -7.4094e-01, -1.8485e+00,  1.4766e+00,  2.2901e-01,  1.5023e+00,
         -3.2748e-01,  1.2463e+00,  3.8577e-01, -3.4778e-01,  7.4142e-01,
          6.4087e-01, -3.2994e-03, -1.3176e+00,  9.4887e-01,  2.8549e-01,
         -3.3758e-01,  4.4792e-01,  8.2648e-01, -5.9769e-01,  9.3186e-01,
          8.1247e-01,  8.7909e-01, -2.0067e+00, -1.1447e+00, -2.2422e-01,
          1.3603e+00,  1.7765e-01, -1.0203e+00, -4.3007e-01, -3.1473e-01,
         -9.5439e-01, -1.6629e+00,  1.5106e+00, -3.3230e-01, -2.0346e-01,
          1.0844e+00, -1.2731e+00,  1.3654e+00, -3.3133e-01,  1.4257e+00,
          2.8431e-01, -7.4210e-01,  2.0834e-01,  1.9805e-01, -5.5987e-01,
          7.3535e-01,  6.8641e-01, -1.0080e+00,  8.2997e-01,  8.7261e-01,
         -5.4841e-01, -5.6013e-01, -1.1264e+00, -9.1787e-01, -1.5226e-01,
          1.5964e+00, -1.1799e+00, -1.3598e+00]])
3: 的    词向量: tensor([[-0.5050, -0.7864,  0.4733,  0.5857, -0.3920, -1.0719,  0.7779,  0.7414,
          1.1750, -0.0547, -0.0028,  0.5988, -0.9794,  0.5023, -0.9066,  0.3467,
          0.1048,  1.0200,  0.9090,  0.7166, -0.0776,  0.2908, -0.0487,  0.2978,
         -0.9683,  1.3314, -0.7385,  0.3636, -1.8954,  1.8396,  0.0174,  0.5640,
          1.0021, -0.3806, -1.3091, -0.3162,  0.6868, -1.1819,  0.9884, -0.5532,
          0.3543, -0.0881, -0.7711, -0.3639,  0.0058, -0.3205,  0.2947, -0.9907,
         -1.1410, -2.0466,  1.1630, -0.0579,  1.5855, -1.0066, -1.8496,  0.9140,
         -0.5690,  0.7007, -0.0466, -1.4705,  1.4759, -1.2716,  0.1965,  0.1914,
         -1.4481,  1.0102, -0.9801, -0.8014, -0.0049,  0.0173, -2.2484,  1.9075,
         -0.9655,  0.9100, -1.4905, -0.6812, -1.1242, -0.8694, -0.7923, -0.7349,
          0.3795, -0.1257,  0.4920, -1.4052,  0.5717,  0.9546, -0.9034, -1.5733,
         -2.4029, -0.4214, -1.7982,  0.4383, -1.5436,  0.4382, -1.0642, -0.6521,
         -0.8291,  0.3413,  0.5453, -0.3017,  1.9028,  1.1402, -1.1944,  0.7615,
         -1.3941,  0.7679,  0.4553, -0.0162, -0.6040,  0.6493,  0.3233,  2.2985,
          0.6532, -1.0028,  0.1517,  0.1298,  0.7207, -1.3053, -1.0424,  1.2343,
          1.0513, -0.2350,  0.3177, -1.6808,  0.9402, -0.4769, -0.0186,  0.3269]])
21: 星   词向量: tensor([[ 0.9343, -0.6351,  2.5973, -0.1343, -0.5938,  0.6907, -1.9802,  1.2802,
         -0.7350, -2.3115,  1.1310, -0.5244,  2.0018, -0.0078, -0.4999,  0.1240,
          1.3521, -1.0262, -0.3435,  1.1001, -1.4145, -0.5343, -0.3016,  1.3090,
         -0.4084, -0.0651,  1.6233, -1.3712, -1.4570, -1.3325,  0.5027,  1.6271,
          1.7070, -0.2588,  0.4852, -0.2199, -0.4746, -2.1739, -0.3085, -0.7908,
          0.6772,  1.5464,  0.6278,  0.4157,  0.0978,  1.3029, -0.1206,  0.9472,
          1.2165,  0.5168, -0.6556,  2.5364,  0.7907, -0.1370, -1.3545, -0.2952,
         -1.6427, -2.1023,  0.3443,  0.2859, -1.1653,  0.3909, -0.1909, -1.0621,
          0.8516, -0.3537, -0.3861, -0.1562, -0.7356,  0.8104,  0.6886, -0.6016,
          0.5568, -0.6973,  0.6600, -0.7863, -0.3930,  0.2882, -1.1542,  1.0403,
         -0.8155,  0.8802, -1.9443,  0.8925,  1.1167, -1.6002, -0.2377,  0.4621,
          0.8763, -0.8899,  0.2207,  0.3117,  0.4775,  0.8951, -0.3195, -1.9292,
         -0.1436, -0.6130,  1.0702, -0.2847, -0.1454, -0.2137, -0.6822,  0.0947,
         -0.7980, -0.3340, -0.4143,  0.4056,  0.8545,  0.3359, -0.3429,  1.8712,
          0.2058,  0.4364,  0.2536,  0.7652,  0.0403, -0.0690, -0.6465,  0.0350,
         -0.3616,  0.3416,  0.4873, -0.6190,  0.2839,  1.4134, -0.8080, -0.1496]])
22: 如果  词向量: tensor([[ 0.1246,  1.2048,  1.4993,  0.2169, -0.6324,  0.3480,  0.5321, -0.4643,
          0.1853, -0.2201, -0.4717,  0.7266, -0.3807, -1.1129,  1.1964,  0.6585,
          1.2434, -0.0832, -1.5133,  0.7713, -0.8878,  0.5984,  0.7236,  0.3181,
         -0.7097,  1.2266, -0.4268, -0.3424,  0.6792, -1.2795,  0.4660, -0.9344,
         -1.3268,  0.2262, -1.2773,  1.2925,  0.4822,  0.6024,  0.2507,  0.2106,
          0.1559,  0.0466,  0.7026,  0.8076, -2.9059, -1.9419,  2.2187, -1.6862,
         -0.3676, -0.8750,  0.3967, -1.0897,  0.7214, -1.0434, -0.9400,  0.9683,
          0.4671,  0.7030, -0.8523,  0.0555, -0.6136,  0.5558, -0.4495,  0.4403,
          0.8187, -1.5777, -0.7845,  1.0370,  0.4199,  0.7749,  1.2567, -0.3439,
         -0.3614, -1.3200, -1.0704, -0.9868,  1.0314,  1.9150,  1.4884,  0.2266,
         -2.5519, -0.6866, -1.1764,  0.7929, -2.9061,  0.5399,  0.0444, -0.2442,
         -0.1906,  0.4717,  1.3004,  0.4692,  0.6341, -0.8144,  0.0730, -1.9063,
          0.6340,  1.0164,  0.7114,  3.6052,  0.6208,  0.4212, -0.8814,  0.8068,
         -1.5279, -0.1897,  1.7267,  0.2021,  1.9491,  2.0983, -0.2440, -0.0369,
         -0.9810,  0.0416, -1.5853, -0.9668, -0.3975,  0.6687,  1.0153, -1.6619,
          0.2119,  0.1046, -0.0508,  0.1504, -0.0602,  1.0055,  0.1538,  0.1054]])
23: 听   词向量: tensor([[ 1.2544,  0.9021, -0.4938,  2.3340,  0.3996, -0.6306,  0.2922, -0.8091,
          1.6602,  1.8169, -0.8131, -0.1887,  1.7214, -1.0289,  1.1330, -1.0458,
         -0.7295, -0.1894,  0.1186,  1.1407,  0.8980, -1.5787,  0.3620, -0.9011,
         -0.5341,  0.4732, -0.0771, -1.0971,  0.6488,  0.5311, -1.2628, -0.3052,
         -0.1396, -1.3593,  0.9019,  0.5569,  0.8465, -1.5078,  0.5944,  0.1621,
          0.3068,  1.3318, -0.7125,  0.5898, -1.1402,  1.4340,  1.3863,  1.4169,
          1.3509, -0.7427,  0.4680,  0.8152,  0.6923,  0.1683, -0.0130,  0.2283,
         -0.0542, -0.4965,  0.1802, -0.8256,  0.4025, -0.0358, -0.5260,  0.3125,
          1.2364,  1.0025,  0.2867, -2.1741,  2.1622, -1.1709,  1.3145,  0.8909,
          0.7970,  0.3928, -0.2470, -0.9782,  1.9170,  0.1687,  0.1538, -0.6906,
         -0.5534, -0.3445,  1.1270, -0.1708,  0.9009,  2.3711, -1.2261,  0.2222,
         -2.5274, -0.4691,  0.6888,  0.5456,  0.7658, -0.6966,  1.4674, -0.6560,
          0.7415, -0.4231,  0.1107, -0.9721,  0.4802, -0.0400, -0.3285, -0.9941,
         -2.7940,  1.0055, -0.3630, -0.4238,  0.4130,  0.4586,  0.4073,  1.1068,
         -0.4705, -1.2360,  0.7293,  1.0668, -1.2555, -0.1846,  0.9244, -2.0131,
          1.5062,  0.2711, -1.8606, -0.3787,  1.3292,  2.0386,  0.7979, -1.6072]])
3: 的    词向量: tensor([[-0.5050, -0.7864,  0.4733,  0.5857, -0.3920, -1.0719,  0.7779,  0.7414,
          1.1750, -0.0547, -0.0028,  0.5988, -0.9794,  0.5023, -0.9066,  0.3467,
          0.1048,  1.0200,  0.9090,  0.7166, -0.0776,  0.2908, -0.0487,  0.2978,
         -0.9683,  1.3314, -0.7385,  0.3636, -1.8954,  1.8396,  0.0174,  0.5640,
          1.0021, -0.3806, -1.3091, -0.3162,  0.6868, -1.1819,  0.9884, -0.5532,
          0.3543, -0.0881, -0.7711, -0.3639,  0.0058, -0.3205,  0.2947, -0.9907,
         -1.1410, -2.0466,  1.1630, -0.0579,  1.5855, -1.0066, -1.8496,  0.9140,
         -0.5690,  0.7007, -0.0466, -1.4705,  1.4759, -1.2716,  0.1965,  0.1914,
         -1.4481,  1.0102, -0.9801, -0.8014, -0.0049,  0.0173, -2.2484,  1.9075,
         -0.9655,  0.9100, -1.4905, -0.6812, -1.1242, -0.8694, -0.7923, -0.7349,
          0.3795, -0.1257,  0.4920, -1.4052,  0.5717,  0.9546, -0.9034, -1.5733,
         -2.4029, -0.4214, -1.7982,  0.4383, -1.5436,  0.4382, -1.0642, -0.6521,
         -0.8291,  0.3413,  0.5453, -0.3017,  1.9028,  1.1402, -1.1944,  0.7615,
         -1.3941,  0.7679,  0.4553, -0.0162, -0.6040,  0.6493,  0.3233,  2.2985,
          0.6532, -1.0028,  0.1517,  0.1298,  0.7207, -1.3053, -1.0424,  1.2343,
          1.0513, -0.2350,  0.3177, -1.6808,  0.9402, -0.4769, -0.0186,  0.3269]])
24: 见   词向量: tensor([[ 0.7362, -1.4712,  1.2106, -0.4481,  0.3059, -0.3769, -0.3850,  1.1246,
         -0.4344,  0.9222, -0.5994, -0.4479,  1.4162, -1.3390, -1.6539,  1.8394,
         -1.2221,  1.5845, -1.1930,  1.1310,  0.3554, -0.0841, -0.7046, -1.2362,
         -0.6700,  2.4575,  1.5531,  0.2896,  0.6560,  1.0525, -0.1828,  0.7062,
         -1.3173, -0.0787, -0.5038, -2.3971,  0.4665,  2.1829, -0.1454, -1.2375,
          0.4456, -0.1730,  0.9735, -0.0640, -0.9733,  0.9785,  0.9200,  0.0025,
         -0.1969, -0.4680, -1.8549,  0.5413, -1.8929,  0.3384,  0.9737, -0.2777,
          0.1088,  1.2688, -0.0298, -0.6080, -1.5854,  0.0967, -0.1646,  0.8230,
         -1.1896, -0.0592, -0.0293,  0.5168,  0.2211, -0.5586, -0.2930, -1.6045,
          0.5938,  0.2630, -1.0017,  0.4197, -0.3070, -1.9273, -1.8329, -0.1540,
          0.5780, -0.9059,  0.5529,  1.3260,  0.3143,  0.5037,  0.0775,  0.2414,
         -0.5057,  0.3852, -0.4010,  1.0541,  1.1464,  0.8323, -0.5967,  1.2612,
         -0.6690, -0.6840, -0.9773, -0.8996,  0.0482, -0.0055,  0.1377,  0.7025,
          0.0617,  0.7621,  1.5706,  0.8205, -0.4286,  1.3250, -0.1531, -0.0703,
         -1.0932, -0.5865, -0.4240, -1.2477, -0.1975, -0.2549,  0.5158, -0.0439,
         -0.5585, -0.0480, -0.7398,  2.1300, -0.9802, -0.0223,  1.9863, -2.0320]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
4: 它    词向量: tensor([[ 0.5916, -1.0563,  1.2493,  0.7314,  1.2289,  0.7857,  0.1050,  0.5233,
         -0.3904,  1.3847, -1.5685, -0.4917, -0.1517,  1.7520, -0.8190, -0.1675,
         -1.3133,  0.8705,  0.7957,  0.1744,  0.8354,  0.6104,  0.2760, -0.4395,
         -0.2033,  0.0680,  0.9529, -1.0169, -0.7344,  1.0691,  0.3209,  0.4052,
          0.7633,  1.9166,  0.0961, -1.2044, -0.2926, -0.1764, -0.7288,  0.1354,
          0.5887,  0.2954,  0.1310,  1.3626,  0.0274,  0.1746, -1.3382,  1.2703,
          0.9801, -0.6425,  1.1956,  0.6877,  2.4781, -0.7597, -1.1181, -0.3879,
          0.1513, -2.1913, -0.1680, -2.7475,  1.8495, -0.6694,  0.1333,  0.7756,
         -1.0243, -1.3028, -0.9127,  0.4272,  0.3535,  0.7610,  1.2806,  0.9609,
         -0.6524,  0.1703,  1.1705, -0.5499,  0.8303,  1.2069,  2.1746,  0.3545,
         -0.1621, -0.1059, -1.1698, -0.4564,  0.1297,  0.0899, -1.5461,  0.0992,
          0.0704,  2.3755, -0.4975, -0.0843, -0.1291,  2.9284,  0.0932, -1.7693,
          1.0329, -1.0583,  0.7528,  0.2621, -0.6719,  0.9021, -0.5467, -0.9155,
          0.2840, -0.1062, -1.0615,  0.2068, -1.1440,  1.1453, -0.2993,  2.2820,
          1.1952,  1.1511,  0.6852,  0.4618, -1.6429,  0.2492,  0.5235, -1.0211,
         -1.6268, -1.1363, -1.7695,  0.6146, -0.0123,  0.2200,  0.4970, -0.4545]])
5: 一定   词向量: tensor([[ 1.2313e+00,  4.5803e-01, -1.0245e+00,  8.1082e-01,  5.8335e-01,
         -8.5283e-01,  1.0435e+00,  8.9049e-01,  1.4090e+00,  4.7953e-01,
          2.1237e+00, -1.4484e+00,  1.0245e+00, -4.9148e-01, -1.1194e-01,
         -9.3104e-01, -1.7203e+00, -3.3872e-01,  7.6409e-01,  1.1902e+00,
         -1.5168e+00, -1.8148e-01, -5.0774e-01,  6.8826e-01,  8.9191e-01,
          2.2935e-01,  1.3293e-01,  9.2889e-04,  2.3604e+00, -2.2407e+00,
          1.5633e+00, -2.8127e-01, -1.7008e+00, -4.7021e-01, -3.5090e-01,
          2.1340e+00, -7.8498e-01, -1.1078e+00, -1.3837e-01, -5.3655e-01,
          4.7906e-01,  1.6595e+00, -1.0748e+00, -2.5242e-01,  6.4267e-02,
          5.7673e-01, -7.6405e-01,  3.6373e-01, -1.1225e+00, -1.1487e+00,
          2.8528e-01,  8.0939e-01, -7.5029e-01, -1.7576e-01, -9.6853e-01,
         -5.7401e-01, -9.3717e-01,  5.6623e-01, -3.4602e-01, -2.3836e+00,
          2.3034e-01,  1.0035e+00,  1.7825e+00, -1.0826e+00, -2.3943e-03,
          1.2059e+00, -3.3547e-01,  8.3382e-01, -3.0155e-01, -7.3170e-01,
         -1.1627e+00,  1.1664e+00, -1.0954e+00, -1.4304e+00,  2.4684e-01,
         -9.4767e-01, -3.6145e-01, -1.0142e+00,  1.8561e-01,  2.7217e+00,
          2.8907e-01,  1.4693e-01,  8.9869e-01, -6.0849e-02,  2.1282e-01,
          1.2202e+00, -2.2507e-01,  8.0473e-01,  9.2867e-01,  4.1824e-01,
         -9.1914e-01,  5.4643e-01, -6.9789e-01,  1.0888e+00,  7.4573e-01,
         -1.1722e+00, -1.5506e+00,  1.3988e+00, -1.2377e+00,  7.9709e-01,
         -4.1322e-02, -2.2761e-01, -5.1566e-01,  1.7174e+00, -2.4986e+00,
          1.5490e+00,  8.7587e-01, -6.0875e-01, -1.8899e-01, -1.9690e-01,
         -2.7263e-01,  1.4313e+00, -1.1703e+00, -1.0822e+00,  1.7274e+00,
         -7.1926e-01,  1.4563e+00,  1.7508e-01,  1.1314e+00, -6.4319e-01,
          9.1328e-01, -7.9965e-01,  1.4625e+00, -9.2181e-01,  1.3153e+00,
          3.3298e-01, -2.0157e+00, -1.5097e+00]])
6: 实现   词向量: tensor([[ 1.0926e-01, -3.9009e-01, -1.9415e-01,  6.4970e-02, -2.4715e-01,
          5.0884e-01, -6.3888e-01, -1.0772e+00, -6.8568e-01, -9.5716e-01,
         -2.4326e-01, -5.2359e-02, -9.9621e-01,  2.3951e+00, -1.4536e-01,
          9.9262e-01, -6.5230e-01, -6.0988e-01,  8.1966e-01,  2.2814e+00,
         -6.1732e-01, -9.4800e-01, -2.1926e-01, -5.0263e-01,  2.0673e-01,
         -1.1291e+00, -8.8755e-01,  8.2712e-01, -6.9201e-02, -2.8709e-01,
         -3.6867e-02,  1.7624e+00, -2.8595e-01, -5.4195e-03,  8.5137e-01,
         -5.8569e-01,  8.4966e-01,  3.5678e-01, -6.3139e-02,  1.0690e+00,
         -4.6396e-01, -4.6860e-01, -6.7270e-01, -7.8498e-01,  3.1458e-01,
         -3.3875e-01,  2.7294e+00,  3.2299e-01, -1.9131e+00,  6.1479e-01,
         -3.6987e-01, -1.4290e-02, -1.7148e+00, -1.5682e-02, -1.3152e+00,
         -1.0467e+00,  1.5903e+00,  6.2825e-01,  9.9813e-01, -1.3689e+00,
          4.5732e-01, -6.2837e-01,  1.0551e+00,  6.7639e-01,  1.2566e-01,
         -1.1856e-02, -7.7169e-01, -1.9395e+00,  5.4226e-01,  1.5230e+00,
          3.7949e-01, -5.4299e-01,  3.9010e-01,  9.7130e-02, -1.2557e+00,
         -4.7758e-01,  2.2550e-01,  1.2194e+00,  7.4347e-01, -5.6995e-01,
          6.9029e-01,  4.0881e-02,  7.5411e-01, -9.8277e-01, -8.7063e-01,
          3.2578e-01, -7.3621e-01, -1.0762e+00,  9.4652e-01,  8.2750e-01,
         -1.0640e+00,  7.8649e-01,  1.5135e+00, -9.6734e-01,  9.6932e-03,
         -1.3051e+00, -3.2069e-01, -1.0847e+00,  7.4306e-01,  3.5581e-01,
         -2.4428e-01,  4.5607e-01,  7.4739e-01, -6.4819e-01, -1.5006e-01,
         -6.1586e-01,  2.9964e+00,  1.3413e+00,  2.8650e-01, -1.8197e-03,
         -6.7891e-01, -9.4347e-02, -9.0407e-01,  4.4775e-01, -6.3878e-01,
         -1.0743e+00,  1.3872e+00,  3.3750e-01, -8.2506e-01, -2.2975e-01,
         -1.5826e+00, -1.9349e+00, -4.6668e-01,  6.8606e-01, -1.8853e-01,
         -8.4801e-01, -1.4381e+00,  7.6804e-01]])
4: 它    词向量: tensor([[ 0.5916, -1.0563,  1.2493,  0.7314,  1.2289,  0.7857,  0.1050,  0.5233,
         -0.3904,  1.3847, -1.5685, -0.4917, -0.1517,  1.7520, -0.8190, -0.1675,
         -1.3133,  0.8705,  0.7957,  0.1744,  0.8354,  0.6104,  0.2760, -0.4395,
         -0.2033,  0.0680,  0.9529, -1.0169, -0.7344,  1.0691,  0.3209,  0.4052,
          0.7633,  1.9166,  0.0961, -1.2044, -0.2926, -0.1764, -0.7288,  0.1354,
          0.5887,  0.2954,  0.1310,  1.3626,  0.0274,  0.1746, -1.3382,  1.2703,
          0.9801, -0.6425,  1.1956,  0.6877,  2.4781, -0.7597, -1.1181, -0.3879,
          0.1513, -2.1913, -0.1680, -2.7475,  1.8495, -0.6694,  0.1333,  0.7756,
         -1.0243, -1.3028, -0.9127,  0.4272,  0.3535,  0.7610,  1.2806,  0.9609,
         -0.6524,  0.1703,  1.1705, -0.5499,  0.8303,  1.2069,  2.1746,  0.3545,
         -0.1621, -0.1059, -1.1698, -0.4564,  0.1297,  0.0899, -1.5461,  0.0992,
          0.0704,  2.3755, -0.4975, -0.0843, -0.1291,  2.9284,  0.0932, -1.7693,
          1.0329, -1.0583,  0.7528,  0.2621, -0.6719,  0.9021, -0.5467, -0.9155,
          0.2840, -0.1062, -1.0615,  0.2068, -1.1440,  1.1453, -0.2993,  2.2820,
          1.1952,  1.1511,  0.6852,  0.4618, -1.6429,  0.2492,  0.5235, -1.0211,
         -1.6268, -1.1363, -1.7695,  0.6146, -0.0123,  0.2200,  0.4970, -0.4545]])
5: 一定   词向量: tensor([[ 1.2313e+00,  4.5803e-01, -1.0245e+00,  8.1082e-01,  5.8335e-01,
         -8.5283e-01,  1.0435e+00,  8.9049e-01,  1.4090e+00,  4.7953e-01,
          2.1237e+00, -1.4484e+00,  1.0245e+00, -4.9148e-01, -1.1194e-01,
         -9.3104e-01, -1.7203e+00, -3.3872e-01,  7.6409e-01,  1.1902e+00,
         -1.5168e+00, -1.8148e-01, -5.0774e-01,  6.8826e-01,  8.9191e-01,
          2.2935e-01,  1.3293e-01,  9.2889e-04,  2.3604e+00, -2.2407e+00,
          1.5633e+00, -2.8127e-01, -1.7008e+00, -4.7021e-01, -3.5090e-01,
          2.1340e+00, -7.8498e-01, -1.1078e+00, -1.3837e-01, -5.3655e-01,
          4.7906e-01,  1.6595e+00, -1.0748e+00, -2.5242e-01,  6.4267e-02,
          5.7673e-01, -7.6405e-01,  3.6373e-01, -1.1225e+00, -1.1487e+00,
          2.8528e-01,  8.0939e-01, -7.5029e-01, -1.7576e-01, -9.6853e-01,
         -5.7401e-01, -9.3717e-01,  5.6623e-01, -3.4602e-01, -2.3836e+00,
          2.3034e-01,  1.0035e+00,  1.7825e+00, -1.0826e+00, -2.3943e-03,
          1.2059e+00, -3.3547e-01,  8.3382e-01, -3.0155e-01, -7.3170e-01,
         -1.1627e+00,  1.1664e+00, -1.0954e+00, -1.4304e+00,  2.4684e-01,
         -9.4767e-01, -3.6145e-01, -1.0142e+00,  1.8561e-01,  2.7217e+00,
          2.8907e-01,  1.4693e-01,  8.9869e-01, -6.0849e-02,  2.1282e-01,
          1.2202e+00, -2.2507e-01,  8.0473e-01,  9.2867e-01,  4.1824e-01,
         -9.1914e-01,  5.4643e-01, -6.9789e-01,  1.0888e+00,  7.4573e-01,
         -1.1722e+00, -1.5506e+00,  1.3988e+00, -1.2377e+00,  7.9709e-01,
         -4.1322e-02, -2.2761e-01, -5.1566e-01,  1.7174e+00, -2.4986e+00,
          1.5490e+00,  8.7587e-01, -6.0875e-01, -1.8899e-01, -1.9690e-01,
         -2.7263e-01,  1.4313e+00, -1.1703e+00, -1.0822e+00,  1.7274e+00,
         -7.1926e-01,  1.4563e+00,  1.7508e-01,  1.1314e+00, -6.4319e-01,
          9.1328e-01, -7.9965e-01,  1.4625e+00, -9.2181e-01,  1.3153e+00,
          3.3298e-01, -2.0157e+00, -1.5097e+00]])
6: 实现   词向量: tensor([[ 1.0926e-01, -3.9009e-01, -1.9415e-01,  6.4970e-02, -2.4715e-01,
          5.0884e-01, -6.3888e-01, -1.0772e+00, -6.8568e-01, -9.5716e-01,
         -2.4326e-01, -5.2359e-02, -9.9621e-01,  2.3951e+00, -1.4536e-01,
          9.9262e-01, -6.5230e-01, -6.0988e-01,  8.1966e-01,  2.2814e+00,
         -6.1732e-01, -9.4800e-01, -2.1926e-01, -5.0263e-01,  2.0673e-01,
         -1.1291e+00, -8.8755e-01,  8.2712e-01, -6.9201e-02, -2.8709e-01,
         -3.6867e-02,  1.7624e+00, -2.8595e-01, -5.4195e-03,  8.5137e-01,
         -5.8569e-01,  8.4966e-01,  3.5678e-01, -6.3139e-02,  1.0690e+00,
         -4.6396e-01, -4.6860e-01, -6.7270e-01, -7.8498e-01,  3.1458e-01,
         -3.3875e-01,  2.7294e+00,  3.2299e-01, -1.9131e+00,  6.1479e-01,
         -3.6987e-01, -1.4290e-02, -1.7148e+00, -1.5682e-02, -1.3152e+00,
         -1.0467e+00,  1.5903e+00,  6.2825e-01,  9.9813e-01, -1.3689e+00,
          4.5732e-01, -6.2837e-01,  1.0551e+00,  6.7639e-01,  1.2566e-01,
         -1.1856e-02, -7.7169e-01, -1.9395e+00,  5.4226e-01,  1.5230e+00,
          3.7949e-01, -5.4299e-01,  3.9010e-01,  9.7130e-02, -1.2557e+00,
         -4.7758e-01,  2.2550e-01,  1.2194e+00,  7.4347e-01, -5.6995e-01,
          6.9029e-01,  4.0881e-02,  7.5411e-01, -9.8277e-01, -8.7063e-01,
          3.2578e-01, -7.3621e-01, -1.0762e+00,  9.4652e-01,  8.2750e-01,
         -1.0640e+00,  7.8649e-01,  1.5135e+00, -9.6734e-01,  9.6932e-03,
         -1.3051e+00, -3.2069e-01, -1.0847e+00,  7.4306e-01,  3.5581e-01,
         -2.4428e-01,  4.5607e-01,  7.4739e-01, -6.4819e-01, -1.5006e-01,
         -6.1586e-01,  2.9964e+00,  1.3413e+00,  2.8650e-01, -1.8197e-03,
         -6.7891e-01, -9.4347e-02, -9.0407e-01,  4.4775e-01, -6.3878e-01,
         -1.0743e+00,  1.3872e+00,  3.3750e-01, -8.2506e-01, -2.2975e-01,
         -1.5826e+00, -1.9349e+00, -4.6668e-01,  6.8606e-01, -1.8853e-01,
         -8.4801e-01, -1.4381e+00,  7.6804e-01]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
25: 载著  词向量: tensor([[ 0.0130, -1.4442, -0.1159,  1.7674,  1.1045, -0.0127, -2.1541,  0.8694,
         -1.5281, -0.3458, -0.3053, -0.3947,  1.3160, -1.9775,  1.9472,  0.0337,
         -0.1300,  1.6106,  0.3540,  0.1020,  0.1342,  0.3241,  1.0377,  0.0238,
         -1.0631,  1.0980,  1.3228,  0.1006, -0.3086,  0.0924, -1.0263, -0.3253,
         -0.6838,  0.6012, -0.9547,  0.1487, -0.7481, -1.2261, -1.8033, -0.7746,
         -0.9505,  0.0416,  0.4279, -1.8811, -0.6799, -0.6689,  0.4292,  0.2898,
         -1.6674, -0.4637,  0.3331,  2.2861, -1.2305, -0.5207, -0.4132, -1.6243,
          0.9616,  0.1419,  1.2081, -1.0937, -0.0821, -0.5604,  0.5080, -1.0553,
          2.7479, -0.7037,  0.1400, -1.8362, -1.9336, -0.2423,  0.7988, -1.2030,
         -0.6264, -0.1811,  1.9042, -1.3571,  1.4924,  0.1017,  1.9865,  0.3771,
         -0.8864, -0.5777, -1.1338, -0.3651,  0.5492, -2.2099,  0.4397,  1.7691,
         -0.3087, -0.2277, -1.1842, -1.0426,  0.4771, -0.3086, -0.9765,  0.6117,
         -0.1084, -0.1830, -0.2647,  0.1288, -0.9891,  0.4511,  1.7160, -0.2620,
         -1.1222,  0.3238, -2.1957,  1.3118, -0.5672,  0.5805,  0.1584, -1.9377,
         -0.8131, -2.2030,  0.6335,  0.2707, -1.4031,  0.2158, -1.5485,  1.2137,
          1.1471,  0.2171,  0.6865, -0.3507,  0.0420, -0.2295, -0.3680,  2.6944]])
2: 你    词向量: tensor([[-0.2350,  0.2923, -0.5940,  0.4420, -0.5620,  0.6781,  0.6996,  1.1685,
         -1.1202,  1.1702,  1.7431,  1.1335, -0.2978, -0.8452, -0.1611, -0.7057,
         -1.2757, -0.4136, -0.8584,  0.7088,  1.0133,  0.6883,  0.7639,  0.3339,
         -0.0689, -0.8740,  0.1080, -0.2372, -0.0766, -1.1628,  1.2577, -1.4728,
         -0.8391,  0.1434, -0.7532,  0.1123, -0.0730, -0.3895, -0.8914,  1.0943,
          0.9030,  0.6517,  1.9855, -0.5613, -0.9821, -0.0886,  0.6993,  1.1337,
          0.0435, -1.1503,  1.6857, -0.9903, -0.1018, -2.5759,  0.3399,  0.7758,
         -1.5326, -0.9689, -0.0901,  0.1434,  2.1109,  1.5606, -1.2908, -0.8750,
         -0.1149,  0.3210,  1.2538,  0.2164, -1.1185, -1.3347, -0.1046, -1.3265,
         -0.0519,  1.7280, -0.8752, -0.2027,  0.0870,  0.3137,  2.1226,  0.7773,
         -0.4965,  1.2673,  0.9419,  0.0753,  1.3247, -0.2009, -0.1344,  1.8694,
         -0.8257, -1.2295, -0.1927,  0.9116, -0.9511,  2.7437, -0.3050,  0.6188,
         -0.6865,  0.1427,  0.6941, -0.4649, -1.3865,  0.1717,  0.4214, -1.9276,
          0.1772,  0.2489, -0.8077, -0.8780, -0.4985,  0.4747, -2.3380,  1.7014,
         -2.1964,  0.3989,  0.0545,  0.6022, -0.4869, -1.9906, -1.0134,  0.2028,
         -0.0669,  0.2856, -0.4412,  0.8217,  0.0568,  1.1643, -1.0116,  1.9836]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
26: 彷   词向量: tensor([[ 2.0638e-01,  1.7918e-01, -1.6845e+00, -1.6166e+00, -9.5709e-01,
         -9.1953e-01,  8.3249e-01,  6.5709e-01, -4.5395e-01,  4.9919e-01,
          3.3684e+00, -9.6222e-01, -2.5708e-01,  9.1349e-01,  8.9903e-01,
         -9.6211e-01, -3.0636e-01, -1.0191e+00, -7.3408e-01,  1.1168e+00,
          8.6342e-01,  1.9096e+00, -7.0161e-01,  8.4195e-01, -2.8671e-02,
          3.1279e-01, -1.7202e+00,  9.0489e-01,  2.1504e-01,  4.9763e-01,
         -1.6546e-02, -2.4402e-01,  1.1222e+00, -3.2448e-02, -9.7688e-02,
          8.5689e-01, -3.4795e-02,  1.2967e-01,  3.7968e-01,  2.2878e+00,
          1.7545e-01,  3.3064e-01, -1.2222e-01, -1.2034e-01,  1.3826e-01,
          1.2994e+00,  8.4120e-01, -2.3508e+00, -1.4964e-03,  1.4723e+00,
         -6.2672e-01,  7.6151e-01, -1.0613e+00, -1.5221e-01,  2.6675e-01,
          5.1785e-01,  2.1635e-01,  2.2183e+00, -1.6828e+00,  5.3576e-01,
          3.2945e-01,  1.3455e+00, -2.8959e-01, -1.6541e-01, -7.2238e-01,
          1.5208e+00,  3.2218e+00, -4.7667e-01, -2.0124e+00,  7.7005e-01,
         -3.1791e-01, -2.2316e-01,  5.5996e-02,  1.4482e+00,  5.8317e-01,
          6.7232e-02, -1.0836e+00,  1.9237e+00,  2.2125e-01, -2.2501e-02,
          1.2048e-03,  3.8885e-01, -1.9154e+00, -1.4272e+00,  1.9411e-02,
         -5.8705e-01,  1.3982e+00,  1.3480e-01, -6.3466e-01, -2.4412e-01,
         -2.3098e-01, -1.4719e+00, -7.8848e-01,  5.1966e-01, -5.0305e-01,
          1.3106e+00, -7.7203e-01, -1.4542e+00, -7.8097e-01,  7.1610e-01,
          6.2247e-01, -1.4318e+00, -1.0222e+00,  6.9049e-01,  5.4608e-01,
         -4.3482e-01,  3.2407e-01, -1.3702e-03,  1.5834e+00,  3.8256e-01,
         -6.8818e-01,  1.2793e+00, -1.2762e-01, -2.0133e+00, -2.1265e+00,
         -7.7334e-01,  7.4891e-01, -1.7430e+00, -9.0149e-01, -1.2098e+00,
         -1.0013e+00,  5.9874e-02,  1.3382e+00,  1.8211e+00, -1.0879e+00,
          2.5116e-01, -3.5087e-01,  1.3276e+00]])
27: 彿   词向量: tensor([[ 0.3545,  0.9200,  0.2450,  0.1973, -0.4150,  0.0871,  0.6044, -0.6435,
         -1.8667, -0.7829,  0.0790,  0.9342,  1.7092, -1.4955,  0.4697,  1.3505,
         -1.2273,  0.4795,  1.5599,  1.2343, -0.9477, -2.0274, -0.0503, -0.0280,
          0.4261, -0.9967, -0.9661,  0.5095,  0.5977, -0.9845, -0.9109,  1.7268,
         -0.6637, -0.7102, -0.1051,  0.1794, -0.6248, -0.0737,  2.2374, -1.4089,
          1.3406, -0.4111, -1.2105, -1.5885, -1.7177, -0.0593, -0.5647, -0.2260,
         -0.9655,  0.4805,  0.0861, -1.0524, -0.7211, -0.2645,  0.9490,  0.3667,
         -0.3931, -0.6123, -0.5245, -2.5402, -0.2376,  0.2304, -1.7667, -0.0738,
         -0.5167,  0.0438,  0.1273,  0.3209,  0.1512, -0.3844,  1.1880,  0.2504,
          0.2282,  0.7113,  0.7361,  0.7894,  0.1982,  0.4231,  1.2974, -0.3185,
         -0.0531, -0.5355,  1.0994, -0.6103, -1.3390,  1.1379, -0.3036, -0.2812,
         -1.4810, -0.2329, -2.0360, -0.5474,  0.1371,  1.6883,  0.6546,  1.4727,
         -0.8790,  0.8791, -0.6492, -0.4888, -0.0276, -0.8042, -1.2861, -3.0403,
         -0.3311, -0.5223, -0.8616, -0.9277, -0.1015, -0.7776,  1.2963,  0.3413,
          0.3724, -0.0179,  0.2722,  0.8740,  0.1257,  2.4065,  2.2139, -0.9071,
         -0.6479,  0.1401,  1.6464, -0.1034, -0.2409, -0.1685,  1.0669,  0.2147]])
28: 载   词向量: tensor([[ 2.2927, -0.1556,  0.1948,  0.1058, -0.9095,  1.5347,  0.1037, -0.9865,
          1.5968,  0.7869,  1.7521, -0.7507, -2.4286, -0.0770, -0.4187,  1.0340,
          0.4136,  0.0871, -1.1497,  0.1112, -0.9691,  0.0651,  0.4673,  0.5560,
          1.7580,  0.7309,  1.0291, -0.7700,  0.3698,  0.0497,  1.3715, -1.2193,
          1.2144,  1.2866, -1.2489, -0.0215,  0.6812, -0.4840, -1.2453,  0.1715,
         -0.5785, -1.0193,  0.0938,  1.1645, -1.1046,  0.4792,  1.1986,  0.0237,
          2.5452,  0.7969, -0.3165,  0.7955, -0.4315,  0.8652, -0.7987,  0.4060,
         -0.6243, -0.5340, -1.5854, -0.3623, -1.0397, -0.4544,  0.4102, -0.6597,
          0.5227, -1.1922,  1.3843,  0.1093, -0.0911, -0.0289, -0.1817,  1.6703,
          0.2879, -1.5454,  1.8103,  1.1089,  0.4454,  1.2236,  0.1834,  2.2438,
          0.4571,  0.5952,  0.0425, -0.6352,  1.0600,  0.5906, -0.4696, -1.0117,
         -0.7786, -0.0038,  0.3714, -0.2240,  0.0452, -0.9149, -1.5518,  0.4848,
         -0.2984,  1.4754, -0.5693, -0.3460, -0.1203, -0.9630,  0.7055,  1.8842,
          0.2574, -0.1630,  0.1578,  0.4158, -0.2017,  1.4251,  0.2964,  1.6244,
         -1.5865,  1.5117, -1.0052, -1.3300,  1.3928,  1.3397,  0.8070,  0.5173,
          0.1104, -0.6624, -1.2985, -0.9819,  0.8713, -0.7251, -0.6626,  1.2367]])
29: 著   词向量: tensor([[-0.4609, -0.2471,  0.4085, -0.5945,  0.4617,  2.6537, -1.6894, -1.4264,
         -0.0373,  0.4902,  0.5070, -2.7035,  0.4626, -0.0360,  1.8401,  1.0522,
         -1.3496, -0.0990,  1.4639, -0.4736,  0.9515,  0.9412, -0.3063,  0.7427,
          0.3580,  0.3058,  0.3931, -0.3376,  0.8213,  0.2612, -1.6250,  1.7013,
          1.1387,  1.6242, -0.0913, -0.0833,  0.6456,  0.9076,  0.1719,  0.0250,
          1.3384,  1.7722, -1.1699,  0.3260, -1.9999, -0.0369, -0.3020, -0.4866,
         -0.0539,  0.4095,  0.6190, -0.7274, -0.5045,  0.6066,  0.8903, -0.1151,
          0.6718,  0.1379, -1.1420,  1.2265, -1.9408,  0.0518, -0.0717, -0.1400,
          0.5750,  1.8808,  0.1026,  1.2920, -0.2349,  0.4570,  3.0292, -0.6879,
          1.0702,  0.1245,  0.8513, -0.0917,  0.0102, -0.4408, -1.2079, -0.0123,
         -0.2064,  0.8972, -0.4601, -0.1962, -1.0646, -0.6595,  1.0718, -0.4501,
         -0.1222,  2.4056, -0.6845, -0.0965,  2.5040, -0.8885, -0.4753,  2.0764,
         -1.7804, -0.7555, -0.3801,  1.0043,  0.5187, -0.8202, -0.2324,  0.4584,
          1.2358, -0.2425,  0.4599,  1.2283,  0.6889,  0.4875, -0.9370, -1.0898,
          1.5884,  1.4127,  2.1541,  0.3219,  2.0027,  0.4316, -0.4091, -0.2188,
         -1.5602, -0.5742,  0.1215,  0.7322, -1.3016,  0.3541,  0.1630,  0.8797]])
30: 阳光  词向量: tensor([[-6.6681e-01,  3.1388e-01,  1.9891e-01, -1.9579e+00, -1.3236e+00,
          8.0021e-01, -6.9249e-01, -5.1662e-01, -2.2410e-01,  7.0207e-01,
          1.6730e+00, -1.9667e-01, -2.0531e+00, -1.0278e-02, -1.4487e+00,
          1.2462e+00,  1.7303e-01,  1.2454e+00,  1.6392e-01,  1.1565e+00,
         -9.8996e-01, -1.2486e-01,  1.0502e+00, -1.9623e-01, -1.5182e+00,
          2.9193e-01,  8.4160e-01,  2.0578e-01, -9.4992e-01,  2.1812e+00,
         -8.3680e-02, -2.4540e-02,  4.8220e-01, -1.3317e+00, -5.8058e-01,
         -1.1528e+00, -1.4336e+00, -8.0645e-01,  8.2314e-01, -4.6465e-01,
          2.6950e-01,  2.5201e+00,  4.7925e-01,  1.8191e-01,  5.4016e-01,
         -1.0156e+00, -9.0166e-01, -8.2198e-01, -2.0085e+00,  2.7966e-01,
          1.7198e+00,  1.6327e-01, -5.4052e-01,  7.8048e-01, -5.6496e-02,
         -1.7522e+00, -1.4818e+00, -3.5830e-02,  1.1451e+00,  1.1324e+00,
          4.3634e-01,  3.9944e-01, -1.0802e-01, -1.4442e+00, -7.1127e-01,
         -1.7754e+00,  2.4793e-01,  2.2581e+00,  9.2790e-01, -1.4974e-01,
          3.1582e-01,  1.0705e+00,  1.2466e-01, -2.7784e-01, -1.7259e-01,
          6.2649e-01,  6.6608e-01, -4.2799e-01,  6.7389e-01,  1.6137e+00,
          1.4399e-01,  2.5740e+00, -2.4464e+00,  2.6337e-02, -9.0736e-01,
         -3.0761e-01,  9.4740e-01, -8.6411e-01, -5.6676e-01,  4.4355e-01,
         -6.0534e-01, -2.0130e+00, -1.1328e+00, -1.8299e-01, -6.1543e-01,
         -2.7019e-01, -9.6866e-01, -2.8558e-01, -1.6923e+00,  1.3407e+00,
         -4.8356e-02,  1.2291e+00,  1.5349e+00, -9.8115e-01, -9.6204e-01,
          1.4603e+00, -3.8333e-01,  1.1623e+00,  1.8353e+00, -1.1845e+00,
         -1.5038e-03, -1.3031e+00,  1.8868e+00, -1.2254e+00,  1.7250e+00,
         -4.6208e-01,  8.9387e-01, -1.6488e+00,  7.6882e-01, -1.7052e-01,
          2.6908e-01, -6.5193e-02, -5.0647e-01, -4.8133e-01, -2.4054e-02,
         -3.8189e-01,  1.0427e+00,  1.3326e-01]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
31: 不管  词向量: tensor([[-0.9464, -0.6052,  0.3126,  1.4290,  2.0005,  0.8584,  1.6002, -0.5967,
         -0.3659, -1.6638, -0.1917, -0.1917, -0.6897, -0.5995,  2.3674,  0.6679,
          0.5741, -2.0621,  1.3792,  0.3328, -0.9829,  0.2667, -2.0164, -0.3677,
          0.6888, -2.6394,  0.0337, -1.4745,  1.8685, -1.0525, -1.1835, -0.0969,
          0.5602,  1.3218, -0.2591,  0.5099,  1.5861,  1.2293, -0.3418,  0.9655,
          0.1812,  0.3926,  0.6548,  1.1521,  1.0141,  1.0634, -1.6467,  0.8662,
          0.2042,  0.8573,  1.9409, -0.6745, -1.7629, -0.5597,  1.3174, -0.0809,
         -1.3265, -1.1189,  0.1612, -1.2166,  0.0435,  1.6677,  0.6189, -0.4808,
          1.5639, -0.3744, -0.4279, -0.1212,  0.4054, -0.7304,  0.8854,  0.3845,
         -1.5092,  0.1070, -0.0445, -0.2511, -1.3624, -0.0352,  1.2683,  1.3496,
          0.5806,  0.9147, -0.4457, -0.7512,  1.0327,  0.6721, -0.1766, -1.0790,
          0.0667,  0.4618, -0.5581,  0.7611, -2.1172,  0.4174,  0.5315,  0.5692,
         -0.8661,  0.5378,  0.4122,  1.0156, -0.1269,  1.0359,  0.1050,  0.1159,
         -2.0003, -0.7383, -0.9426,  1.0606,  1.3359, -0.2512, -0.5589, -0.4096,
         -0.9388,  1.1260, -2.0243, -2.3810, -2.5837, -1.0050,  0.3578, -0.6826,
          1.6660, -1.7785, -1.4657,  1.0506,  0.3798,  0.8354,  1.0325, -0.6190]])
32: 到   词向量: tensor([[-1.7293e+00,  7.6618e-01,  1.2457e+00, -8.3565e-02, -1.6795e+00,
         -6.8624e-01, -1.8255e-02,  1.0258e+00,  1.1433e+00,  5.5758e-01,
          1.5512e+00,  2.0042e-01, -1.4405e+00, -8.9225e-01, -7.9894e-02,
         -8.3573e-01, -8.9205e-01, -1.5358e+00, -2.3136e-01, -1.5133e+00,
         -2.0101e-01,  9.2057e-01, -1.5428e+00,  5.5261e-01, -5.8868e-01,
          3.9964e-01,  9.4172e-01,  1.3467e+00,  1.6078e+00,  8.8467e-01,
          1.2418e-01, -4.2634e-01, -6.0308e-01, -1.8785e-01,  5.9931e-01,
          5.3682e-01, -1.6145e-01,  6.0872e-01,  1.2291e+00,  1.7928e+00,
          1.2258e+00, -5.0628e-01,  7.3103e-01, -7.6231e-01, -4.9622e-01,
         -9.2898e-01,  2.6941e+00,  2.9617e-01, -8.6824e-01, -1.6541e+00,
         -6.4260e-01,  1.5887e+00,  1.9627e-02,  1.8426e+00,  6.6561e-01,
         -1.2808e+00,  1.0860e+00,  1.1127e+00,  3.3658e-01,  8.2967e-01,
          7.8014e-02, -1.4274e+00,  1.1754e+00,  4.4043e-01, -9.9647e-02,
          7.8550e-01,  1.5082e+00,  1.7038e+00,  6.4063e-01,  1.9863e+00,
          1.9860e+00,  1.3358e+00,  2.1502e-01, -1.0011e-01,  1.7259e+00,
         -1.4419e+00, -8.8087e-01,  1.6717e+00,  1.7081e+00, -8.1647e-01,
         -2.1245e+00, -6.6736e-01, -1.3917e+00,  8.8490e-01, -4.5910e-01,
          1.0833e+00,  9.0440e-02, -1.6128e-01, -2.4166e+00, -1.9114e+00,
         -4.9039e-01, -1.0321e+00, -1.9241e+00, -4.1589e-01, -4.9464e-01,
          3.9884e-02,  1.4264e+00, -1.0090e+00,  7.2417e-01, -6.8247e-01,
         -5.4365e-01,  3.1351e-01, -3.3199e-01, -1.1638e+00, -6.8961e-01,
          9.4218e-01, -5.3865e-01,  1.3979e+00, -4.9486e-01, -6.6712e-02,
         -5.6468e-02, -4.6435e-01, -3.9127e-01, -2.1858e+00, -2.6374e-03,
         -4.6120e-02, -2.3910e-01, -6.2278e-01, -4.8175e-02, -1.1165e-01,
          8.4639e-01,  3.3255e-01,  1.6826e-01,  8.6989e-01, -1.3513e+00,
          7.0078e-01,  1.1347e+00, -1.7916e+00]])
33: 哪里  词向量: tensor([[-1.4643, -0.6733,  0.2959, -0.1952, -0.1018,  0.0386, -0.1922, -0.5421,
          2.5666, -0.2306,  0.4469, -0.1740, -1.6989,  0.8954,  0.4466, -0.5638,
          0.5447, -0.6224,  0.9208,  0.5154, -0.5738, -0.7667, -1.8900,  1.0274,
         -0.1189,  0.2136,  0.3690,  0.5807,  0.9170,  0.1215, -0.0820, -0.1953,
         -0.1378,  0.1823, -0.4439,  0.5595, -0.1301, -1.3967, -0.4519,  0.5513,
          0.2657,  0.1050,  0.8477, -0.1732, -0.5251, -0.7948,  0.7711,  0.2346,
          0.9837,  1.1456, -1.2671,  0.4402, -1.0754,  0.4043,  0.4300, -1.1614,
         -0.8005,  1.4687, -0.6400, -0.0339,  1.2569, -0.6062,  1.4264,  0.7395,
          0.1630, -1.1712,  0.5811, -0.3621,  0.6328, -0.4657,  0.4631,  0.1303,
          0.2278, -1.0573,  0.4471, -1.5146, -0.9939, -0.5790, -1.9654,  1.8992,
         -1.1681,  0.5045,  1.2638, -1.4513,  0.4989, -2.2016,  0.7756, -0.9715,
          1.2353,  0.0658,  0.1500, -0.2204, -1.1382, -1.0660, -0.6612, -2.2103,
          0.3402,  1.0039,  0.0782, -1.2468, -0.8603, -1.1246, -0.7365,  0.3039,
          1.0979,  1.0798, -0.5041, -0.3765, -0.5015,  1.4325,  0.3214,  0.5275,
          0.8239, -0.3697, -1.5350,  0.0238,  0.0119,  0.4711,  0.2432,  1.0015,
          0.0086,  0.3860,  0.5784, -0.8344,  1.1504,  0.4801,  0.2475,  1.3448]])
34: 都   词向量: tensor([[-1.1040, -0.2448, -1.7101, -0.6372,  0.8819,  0.3487, -1.1393,  0.2709,
         -0.7410, -0.1067,  1.0191, -0.6669,  1.1108, -1.0200,  1.1394,  0.2519,
          1.3242, -0.8859, -0.1807, -0.0494, -1.2886,  1.2777,  1.0099,  0.2565,
          0.5103, -0.8095,  1.5098,  0.1844, -0.8281,  1.0727,  0.5986, -0.2436,
         -1.0959, -0.2728, -0.6333,  0.5404,  1.3417,  0.4069,  0.3982,  1.4103,
         -1.0120, -0.7256, -0.6730,  0.0247, -0.1195, -0.3666,  0.9982, -1.4035,
          0.6242, -1.8441,  0.5665, -0.1932,  1.0155, -0.0217, -0.9399,  1.6921,
          0.7970, -1.1289,  0.9723,  0.5233,  0.8992,  0.5504, -0.0088, -1.7802,
          0.7315, -1.1603,  0.2731,  1.0375,  0.8651, -0.0506,  0.2135, -0.0511,
         -1.2038, -0.4909, -0.4693,  0.4387,  0.7884,  0.1814,  0.4348,  0.7209,
          0.6599, -1.2706, -0.3124, -0.5817,  0.5481, -0.5841, -1.7155, -0.8999,
          0.6258, -0.3484, -0.7053,  0.4315, -1.6577, -0.0441,  0.0373,  1.2164,
          0.7550, -1.0862, -0.2914,  0.2415,  1.0807,  1.7424, -0.8073, -0.0807,
         -0.6910,  0.2095,  1.0607, -1.3497,  0.8184, -0.7912,  0.5244, -1.0989,
          0.0108,  0.5212,  1.2531, -2.2000,  0.0591, -0.7317, -2.4573, -1.2097,
         -0.6044, -0.1179, -0.7387,  0.8334, -0.3104,  1.5265,  0.3675,  2.6542]])
35: 是   词向量: tensor([[-8.2120e-01, -2.8328e-01,  1.6662e+00, -1.6087e+00,  8.6736e-01,
         -6.4053e-01,  4.2528e-01, -6.1368e-01,  6.3542e-01, -1.1060e+00,
         -2.0113e+00,  2.9655e-01,  1.0306e+00,  4.6830e-01,  8.3836e-01,
         -1.6699e-03,  4.6096e-01,  2.2086e+00, -9.2179e-01,  1.9870e+00,
          3.4076e-01, -2.8053e-01, -9.0661e-01,  2.4770e-01, -1.1387e+00,
          2.7342e-01,  4.2476e-01, -1.0907e+00, -1.4633e+00,  1.0174e-01,
         -8.6484e-01, -1.4023e+00, -2.2307e+00, -1.8555e+00, -3.4721e-01,
         -1.7547e+00, -8.0795e-01, -1.3987e+00, -3.8316e-01,  2.1896e-01,
         -2.9757e+00,  9.9645e-01, -4.1250e-01, -1.1160e-01, -1.4714e+00,
         -9.8250e-01,  4.3480e-01,  2.6648e-01, -1.5392e+00, -1.6790e+00,
         -1.8937e+00,  3.8134e-01, -1.4923e+00, -1.5945e-02,  1.8075e+00,
          1.2530e+00,  1.0465e+00,  4.2364e-01, -2.8934e-02, -1.7606e+00,
         -1.7925e+00, -1.6269e+00,  1.8391e-01,  1.5703e+00, -1.7618e-02,
         -5.1381e-01, -4.7056e-01,  6.7110e-01,  1.5954e+00,  5.7706e-01,
         -2.5244e-01,  1.6121e+00, -1.6114e+00, -3.3068e-01,  6.9184e-02,
         -1.7144e-01, -1.0965e-01,  1.2530e+00,  8.9262e-02,  5.7882e-01,
         -1.1490e+00, -3.2062e-01,  3.2360e-01,  4.6964e-02,  7.8878e-03,
          1.5564e-01,  1.5038e+00, -6.0567e-01, -3.7252e-01, -1.1011e+00,
          6.1680e-01, -2.0176e-01, -3.2489e-01,  3.1328e-01,  6.0072e-01,
          3.2597e-01,  6.9676e-01, -6.5529e-01,  6.6205e-02, -4.3353e-01,
         -3.2025e-03, -5.4171e-01,  1.2523e+00,  3.3848e-01, -7.5469e-01,
         -1.8495e+00,  1.3784e+00, -1.1285e+00,  1.1601e+00,  9.1605e-02,
         -3.3379e-01, -1.2874e+00,  1.1333e+00, -6.9849e-01,  3.0190e-01,
         -6.3544e-01,  4.8548e-01,  1.9634e-01, -2.7538e-01,  3.2318e-01,
          1.2272e+00,  1.7607e+00,  6.6594e-01,  3.8842e-01,  6.7394e-01,
          4.0367e-01, -1.8401e-01,  3.1367e-01]])
36: 晴天  词向量: tensor([[-0.9515, -2.0035,  0.9765, -0.2883, -0.8134,  0.0556, -0.2098, -0.1265,
          1.5195,  0.0802, -1.1466, -0.4319, -0.7498, -0.5207, -0.4725,  0.6365,
         -0.0726, -0.7961,  0.2653,  0.0717,  0.9894,  0.3911,  0.7375,  0.8026,
          0.7547,  0.2801,  0.4399, -0.3265, -0.9765, -1.2219,  1.6562, -0.3701,
         -1.9560, -1.1429, -0.1170,  2.2568,  0.7193, -0.6739,  0.2834,  0.5517,
         -0.4053, -0.3769,  0.4368,  2.0275,  0.5619, -0.1478,  0.4074,  1.3673,
         -0.2386,  0.7686, -2.0170,  0.1169,  1.2757, -1.6200, -2.4805, -0.5298,
         -0.5516,  0.3519,  0.8227, -0.1155, -0.4592, -0.2786, -0.7938,  0.1115,
          2.1405, -0.5330,  1.7106,  0.4140, -0.1481,  1.0451,  2.1707, -1.6154,
         -0.6824, -0.7025,  1.4571,  0.5462,  0.2533, -1.9664,  0.4303, -0.2169,
         -0.9560, -0.3117,  0.3301, -0.1070, -0.9566,  0.3362,  1.8394,  1.0272,
          0.0161,  0.7523,  0.0521,  1.5430,  0.6700,  0.4177,  1.4022, -0.3000,
          0.5417,  1.8098, -0.0651,  0.7423,  0.3519,  0.3802, -1.0462,  1.3886,
          0.4424,  1.4787, -0.7734,  1.4286,  0.4675,  0.1979,  0.9512,  0.0780,
         -1.0070, -1.0718,  0.2628,  0.1733, -0.0740, -1.6008, -2.0330,  0.9557,
          0.7744, -2.1375,  1.4451, -0.4186,  0.7063, -0.3801,  0.1497,  2.5435]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
37: 蝴蝶  词向量: tensor([[-0.0400, -3.0574, -0.3635,  0.0669, -0.5588, -1.2091, -1.4738,  0.2054,
         -0.0921, -0.4293, -2.2230, -0.0302,  1.1037,  0.8118, -1.5666,  0.2460,
         -1.0714,  1.3454, -1.0974, -1.7518,  0.9955, -0.2803, -0.1690,  0.9053,
         -1.7695,  0.1259,  1.1383,  0.1016,  0.6136,  0.5402, -0.4232,  0.7554,
         -0.2779, -0.3137,  0.5117,  0.2531, -0.6667,  1.6624, -0.7515,  1.1473,
         -0.9900, -0.3361, -1.6921, -0.9011,  0.0125, -0.2491,  0.9530,  0.7645,
         -1.0743,  1.3598, -0.6045,  0.0985, -0.4107,  0.5621,  0.3941,  1.8453,
         -1.3194,  0.5754, -1.5461, -0.3941, -0.0374, -0.5618,  0.5198, -0.4568,
         -1.5868, -1.1016, -2.0161, -0.2921,  1.1768,  1.0603, -0.9682, -0.4863,
          0.3831, -2.2404,  0.1762,  0.8192, -2.0637,  1.1402,  0.6617,  1.8851,
          1.7079, -0.2097,  0.5858,  0.0674, -0.2334, -0.4106, -0.9226,  1.4199,
         -1.3866, -0.3694, -1.6176,  1.1050,  0.8684,  1.0019, -0.4293, -0.0600,
         -0.8311, -0.3207, -0.5480, -0.3166,  0.6045,  1.1389, -0.2693, -1.2763,
          0.7155, -0.7850,  1.4891,  0.3402, -0.1004, -0.9299,  0.9118,  1.5175,
          0.9601,  0.5925, -0.3684,  0.1902,  0.1856,  0.4328, -1.1945, -0.8295,
         -0.2797,  0.1495,  0.1475,  1.5402, -0.3102,  1.7637,  0.4542,  0.2214]])
38: 自在  词向量: tensor([[-0.0890,  2.0051, -0.4212,  0.7407, -0.1412, -0.2897, -1.2797, -0.1035,
          0.8262,  0.1403,  1.6216, -0.4490,  2.0291, -0.7813,  0.5643,  0.9159,
         -0.6230, -2.3437,  0.8992, -1.1990,  0.8511, -0.9259,  1.0098,  0.1918,
         -0.1001, -0.2540,  0.2757, -0.3057,  1.0016, -0.7917,  0.6704,  1.8217,
         -1.3798, -2.3096,  0.2124,  0.0288,  2.3481,  0.1914, -0.9464,  0.2106,
         -0.9816,  1.1996, -0.1687, -0.5714,  2.5692,  0.4879, -1.0856, -0.3265,
          0.3012,  0.6901,  2.0890,  0.5059, -0.9193,  1.1435, -0.9719, -0.6070,
         -0.2419, -0.6951,  0.8119,  0.3433, -0.7767, -0.6102, -0.0567, -0.1336,
          1.7577, -1.5125,  0.7527,  0.2311, -0.8408, -0.2683, -0.3418, -1.5201,
         -0.9887, -1.1599, -1.3392, -0.6399,  0.0456,  1.6694,  0.8850,  0.4662,
         -0.8431, -0.4383,  1.4793, -0.1043, -0.4125,  1.5138, -1.0306,  0.4325,
         -1.4426,  1.3891,  2.2106,  0.0119,  1.3662, -1.0865,  0.2993,  1.6427,
          0.9929, -0.4652,  0.3751,  0.1675,  0.5255, -1.7891, -0.5643,  2.0388,
         -0.4236,  2.2841,  0.4414, -0.8529, -0.2652,  2.0532,  0.9428, -2.3291,
          0.7312, -0.2203, -2.6520,  0.7018, -0.6359, -1.1981, -1.3476,  0.5686,
          0.6346, -1.3652,  0.0989,  0.3841,  0.7982,  0.3921,  0.2562,  1.1164]])
39: 飞   词向量: tensor([[ 0.1505, -0.5211, -1.3555, -1.6991,  0.0248,  1.0908, -2.4161, -0.4290,
         -0.9339,  0.9067, -0.9893,  0.2206, -0.3759,  0.3800, -1.3682, -0.1715,
         -1.0890, -0.8062, -0.7725, -1.5024,  1.2533, -1.1394, -2.2211,  0.7388,
          0.2162,  0.3735,  1.1901,  1.4049,  1.4705,  0.3772,  0.0564,  0.7979,
          0.3808, -1.5826,  0.8833, -0.0071, -1.5239, -0.0058, -0.1841, -0.6579,
         -0.2287, -0.9190,  0.2217,  0.6823,  0.5909,  0.6026, -0.7251,  0.3107,
          0.3377, -0.7829,  0.6419, -1.3618, -1.1473, -2.2249,  0.1155, -0.0491,
         -0.2913,  1.2379,  1.0540, -1.1968,  0.4840, -0.2500,  0.4143,  0.0701,
         -1.6958, -1.0107, -1.0176, -0.0821, -0.4596,  0.6628,  0.5114,  0.8228,
         -0.0263, -0.3108, -0.0664,  0.7817, -0.0792, -0.6642,  0.4899, -0.7746,
         -1.2100,  0.0668,  0.5627,  1.9854,  1.2941, -0.4958,  1.6721,  0.5782,
         -0.4971,  0.8496, -1.3295,  0.8021, -0.8112, -0.1706,  0.1133, -1.7094,
          1.1023,  0.8259,  1.9681, -0.7125, -1.6230, -0.0514, -0.1862,  0.0737,
          0.5846,  0.7409,  1.2824, -1.1207,  0.0472, -1.7442, -0.3456, -0.5543,
          0.1329,  0.5167,  0.4778, -0.6580,  0.2221, -1.7735, -0.2137,  0.5213,
          0.3882, -0.2364,  0.6884,  0.3610, -0.2606,  0.7823, -1.1167, -0.2934]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
40: 花   词向量: tensor([[ 1.6223e+00, -9.5817e-01, -1.4592e+00,  1.5443e+00,  2.2209e-01,
         -1.9822e+00, -1.8519e+00,  1.1029e-01, -1.6615e-01,  8.0731e-02,
          3.7431e-01,  7.9663e-01,  1.2330e+00, -4.7161e-01, -1.6916e+00,
         -4.4269e-01,  7.8954e-02,  1.1167e+00, -3.8532e-01, -1.1191e+00,
          4.6523e-01,  1.4931e+00,  2.8343e-01,  7.2036e-01,  6.2302e-01,
          1.1892e-01, -1.4169e+00, -1.3503e+00,  9.5121e-01, -1.8075e+00,
          1.3349e+00, -3.1257e-01,  5.2157e-01,  9.8751e-02,  9.1501e-01,
          6.4720e-01, -6.1483e-01, -1.1998e-01,  4.8999e-01, -1.0645e+00,
         -2.1452e-01, -1.3770e+00,  1.8499e+00, -1.2342e+00,  9.5056e-01,
          2.1517e+00, -3.6696e-01, -6.7400e-01, -2.1884e-01,  6.2584e-01,
          4.9954e-01, -4.5436e-01, -9.6446e-01,  1.5823e-01,  7.8843e-01,
          8.5788e-01, -1.0194e+00, -5.0947e-03, -1.1680e+00, -7.5109e-01,
         -7.4497e-01,  9.8633e-01,  1.6304e+00, -3.2880e-01,  8.0259e-01,
         -5.8733e-01, -1.2889e+00,  2.8109e-01, -8.9083e-01, -2.0554e+00,
         -1.2636e+00,  6.7099e-02,  1.0834e+00,  1.1612e+00,  9.3985e-01,
         -2.0706e+00,  1.8427e-01, -4.6557e-01,  9.6158e-01, -1.0032e+00,
          1.7373e+00,  7.1857e-01, -1.3122e+00, -1.6312e+00,  7.2751e-01,
         -6.9314e-01, -6.9697e-02, -8.0559e-01,  2.6991e-01,  8.4679e-01,
          2.1277e-01,  1.3291e-01,  4.0936e-01, -1.1848e+00, -6.7349e-01,
          7.4269e-01, -6.2325e-01, -2.4662e-01, -5.1447e-01,  3.5489e-01,
         -9.5475e-01, -1.0932e+00, -1.2717e-01, -1.3606e+00, -7.7625e-01,
          1.0224e+00, -2.9855e+00, -4.8703e-01,  5.2271e-01,  1.9643e+00,
          1.3821e+00, -3.1085e-01,  1.0357e+00, -1.4043e-01, -2.9865e-02,
         -2.0081e+00, -5.4855e-01,  2.8518e-01,  1.2019e-01,  1.4236e-03,
          2.7062e-01,  1.1406e+00, -2.8399e-01,  5.6629e-02, -5.7652e-01,
          6.6034e-01, -2.9776e-01,  8.1386e-01]])
41: 也   词向量: tensor([[-6.7628e-01, -1.2231e+00, -8.5826e-01, -1.5907e+00,  9.6659e-02,
         -1.0435e+00,  7.8038e-01,  6.3931e-01, -2.2397e-01,  1.0919e+00,
         -3.6329e-01,  1.7266e+00,  8.5129e-02,  1.7637e+00,  1.0250e+00,
         -4.6704e-01,  1.3918e+00, -1.1509e+00,  6.4847e-01, -7.5462e-01,
          3.0993e-01,  1.3801e+00,  1.2410e+00, -6.6719e-01, -9.9027e-02,
          1.3417e+00, -1.0160e+00, -1.7841e+00,  4.6521e-01,  1.0478e+00,
         -9.1776e-01, -2.4109e+00, -1.0396e-01, -1.4302e+00,  1.3115e+00,
          1.4434e+00,  4.4277e-01, -4.1619e-02,  8.4129e-01,  3.5324e-01,
          1.6084e+00,  1.1552e+00,  8.7772e-01,  3.2182e-01, -5.6103e-01,
          6.8060e-01, -4.5383e-01,  1.0746e+00,  1.4843e-01,  1.3553e-01,
          2.4592e+00, -2.1877e-01,  5.8189e-01,  1.3227e+00,  1.0808e+00,
         -2.1273e-01,  9.7085e-01, -1.1326e+00,  2.3754e-01, -2.1791e+00,
         -1.3799e-01, -7.2653e-01, -2.1827e+00, -4.4514e-02,  5.2606e-01,
          6.2988e-01, -5.2788e-02, -7.5509e-01,  9.4722e-01,  2.7789e-01,
         -7.2505e-01, -8.6593e-01,  7.2531e-01,  1.0444e+00, -4.5420e-01,
          1.0472e+00, -7.1261e-01, -4.4027e-01, -7.8621e-01, -2.6592e+00,
         -7.1783e-01, -7.4633e-01, -1.2442e+00,  2.0033e+00,  5.3387e-01,
          1.5952e-01, -2.3704e-03,  1.6082e+00,  4.8052e-01, -4.1368e-01,
         -1.2486e+00, -3.4285e-02,  1.1333e-02, -6.2764e-01, -4.7374e-01,
         -4.3883e-01,  7.5377e-01, -1.4190e+00,  5.0723e-01,  1.4401e+00,
         -1.1395e+00,  5.3203e-01,  2.5143e-01,  2.4624e-01,  2.0348e-01,
          2.8935e-01, -2.9100e+00,  4.4372e-01,  4.0474e-01,  8.5836e-01,
         -1.4738e-01,  4.4940e-01, -1.2206e+00, -1.9185e-01,  1.1428e+00,
          1.1633e-01,  1.2609e-01, -9.0215e-01, -5.8231e-01,  2.5477e-01,
          6.3429e-01, -4.0369e-01,  9.3054e-01, -2.9329e-01, -3.4951e-01,
          8.1288e-02, -2.0352e+00, -1.3720e-01]])
42: 布满  词向量: tensor([[-4.5253e-01,  1.2684e+00,  1.7057e-01,  9.4326e-01, -4.1709e-01,
         -4.4314e-02, -5.4650e-01, -1.4884e+00, -1.7525e+00,  1.7944e+00,
         -5.1579e-01,  6.5650e-01, -7.9460e-01,  5.9025e-01,  2.1915e+00,
         -2.1443e-01, -1.0747e+00, -1.0729e+00,  4.1925e-01, -1.3990e-01,
          2.2697e-01,  1.5757e+00,  5.9371e-01,  7.1543e-02, -2.1005e-01,
          1.9483e+00,  1.0135e+00,  8.0003e-02,  6.8458e-01,  1.3643e+00,
          2.3798e+00,  5.0634e-01, -1.3400e+00,  3.5532e-01, -1.9955e-01,
          1.7431e+00, -1.0468e+00,  1.3643e-01,  1.6486e-01, -1.4376e+00,
          4.1655e-02, -1.2915e+00, -1.2906e-01, -1.1715e+00, -2.1027e+00,
          1.7695e-01, -3.6445e-01,  5.1146e-01, -1.3261e+00, -1.2071e+00,
         -1.0221e+00, -2.7931e-01,  2.0997e+00, -1.0898e+00,  3.2626e-01,
         -7.9737e-01, -5.6796e-01, -9.3576e-01,  2.8312e+00, -6.4564e-02,
         -1.6108e+00,  1.0971e+00,  5.6300e-01, -2.1304e+00,  8.5615e-01,
         -1.6809e-01, -1.8408e-01,  2.5422e-02, -4.0539e-01, -1.1370e+00,
         -4.2277e-01,  2.2772e-01,  8.1919e-01, -4.0291e-01,  7.0270e-04,
         -1.4806e+00,  4.6460e-01,  1.5019e+00, -2.8855e+00,  2.5376e-01,
          7.6675e-03, -2.1994e-01,  2.0591e+00, -3.9508e-01, -1.1114e+00,
          1.1211e+00,  3.9303e-01,  1.0362e+00, -5.5384e-01,  1.2727e+00,
         -1.2753e+00,  7.9594e-01,  3.9921e-01, -2.1216e-01,  4.1584e-01,
          1.1322e+00,  4.2213e-01, -8.8632e-01, -1.4457e+00,  1.2618e+00,
          1.4342e+00,  7.5508e-02,  7.7594e-01, -1.2284e+00, -1.4598e+00,
         -8.1313e-01, -7.7488e-01,  3.7278e-01,  1.4813e+00, -1.8646e-01,
         -8.9246e-01, -8.6041e-01, -3.5563e-01,  1.5553e+00,  1.2483e+00,
         -1.2193e+00, -1.6430e+00,  5.2919e-01,  9.0076e-01, -6.3405e-01,
          2.4560e-04, -6.9363e-01, -2.7712e-01,  2.0122e-01,  9.3922e-01,
         -1.2071e+00, -9.4478e-01, -2.4938e+00]])
43: 天   词向量: tensor([[ 0.6787,  0.5562,  1.2362,  1.3772, -0.0162, -1.2678,  0.3929,  0.1114,
          0.7642,  0.0986,  0.1139,  1.0605,  1.4362, -2.0456,  0.8168, -1.6170,
          1.6338, -0.1835, -1.5192,  0.7876, -2.0830,  0.3325, -0.2090,  0.5700,
         -1.4786, -1.2677,  0.1142, -0.2664,  0.7965, -1.6880,  0.0061,  0.0397,
          2.3898, -0.2688, -0.9833, -1.4358, -0.0378, -0.1717, -0.1442, -0.8028,
          1.0593, -0.3457,  0.2422,  0.2237, -0.7803,  1.0759,  0.8889,  0.0160,
         -1.7623, -2.9322, -0.9920, -0.6178,  0.0272,  0.0790, -1.1477,  2.4297,
         -0.9211,  1.6385,  0.5648, -1.5323, -1.1366, -0.5470, -0.6924,  1.8343,
         -1.2098,  1.1172,  1.7328, -0.4984, -1.4761, -0.0402, -0.6028,  0.7889,
         -0.4026,  1.0294, -0.5683,  1.0917, -1.0194, -1.5754, -0.2576, -1.3578,
         -0.1577,  1.6544, -0.3081,  1.5000,  1.0419, -0.2156,  1.7456, -0.1576,
          1.0433,  0.6680, -0.3189,  0.2969, -0.2939, -1.7309,  2.0627, -0.6846,
         -0.8100, -2.1868,  0.5834,  2.0086, -0.5590, -0.5323,  0.2037, -1.5073,
          2.2249,  0.7154,  0.0607, -1.2099, -0.4010,  1.0810,  0.9910,  0.4656,
          0.3364, -0.9702,  0.3221, -0.3232, -1.8185,  0.0825,  1.0955,  0.1303,
         -0.1656,  0.3935, -0.1586,  0.9302,  1.2459,  2.4649, -0.2167, -0.1001]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
7: 一朵   词向量: tensor([[ 0.3096, -1.0921,  0.0507, -1.4102, -1.6641, -0.0777,  0.7555,  0.7956,
          0.7948,  0.8727,  1.9170,  3.4420, -0.8712,  0.1161, -1.0912, -2.0824,
          0.0259, -1.0647, -0.5117,  1.5172, -0.0385, -0.3116,  1.7770, -0.8633,
         -0.5530,  0.4903,  0.1786, -0.0834, -0.1454, -1.0511, -0.6035,  0.3540,
         -0.6492, -0.6907, -0.5937,  0.2177, -0.3159,  0.4670,  0.4429, -1.8321,
         -0.1668,  0.3966,  1.5405,  0.4017,  0.9508, -1.8645,  0.4707, -0.5419,
          0.2048, -0.0637,  1.7019,  0.6493,  1.0908,  0.6885, -1.8013, -0.9422,
         -0.1981, -0.4192, -0.7153, -1.2981,  1.0295, -0.5339,  0.1464,  0.2236,
         -1.4971, -0.4581, -1.1740,  1.1611,  0.3127, -0.0834,  0.5868,  1.5329,
         -0.9288,  1.8301, -1.2567, -0.4465, -1.2352,  0.4739, -0.8452,  2.2686,
          0.4098,  1.6155, -0.0646,  1.8567, -1.8655,  0.2523,  1.0969, -0.5596,
         -0.1209,  0.4286,  1.5780,  0.0447,  0.7614, -1.2196, -0.5788,  0.4128,
          0.2822, -0.7087,  0.7638, -1.2023, -1.4040, -0.3361,  0.0961, -1.2491,
         -1.2159,  1.7288, -1.5975, -0.7892, -0.3213,  0.4886, -0.4395,  0.8248,
         -0.1356,  1.0946, -0.0798, -1.0341,  0.5240,  0.0456, -0.4374,  0.5594,
         -0.8723, -0.1566, -2.3145, -1.2582,  0.4562,  0.2723, -1.0719, -0.1717]])
7: 一朵   词向量: tensor([[ 0.3096, -1.0921,  0.0507, -1.4102, -1.6641, -0.0777,  0.7555,  0.7956,
          0.7948,  0.8727,  1.9170,  3.4420, -0.8712,  0.1161, -1.0912, -2.0824,
          0.0259, -1.0647, -0.5117,  1.5172, -0.0385, -0.3116,  1.7770, -0.8633,
         -0.5530,  0.4903,  0.1786, -0.0834, -0.1454, -1.0511, -0.6035,  0.3540,
         -0.6492, -0.6907, -0.5937,  0.2177, -0.3159,  0.4670,  0.4429, -1.8321,
         -0.1668,  0.3966,  1.5405,  0.4017,  0.9508, -1.8645,  0.4707, -0.5419,
          0.2048, -0.0637,  1.7019,  0.6493,  1.0908,  0.6885, -1.8013, -0.9422,
         -0.1981, -0.4192, -0.7153, -1.2981,  1.0295, -0.5339,  0.1464,  0.2236,
         -1.4971, -0.4581, -1.1740,  1.1611,  0.3127, -0.0834,  0.5868,  1.5329,
         -0.9288,  1.8301, -1.2567, -0.4465, -1.2352,  0.4739, -0.8452,  2.2686,
          0.4098,  1.6155, -0.0646,  1.8567, -1.8655,  0.2523,  1.0969, -0.5596,
         -0.1209,  0.4286,  1.5780,  0.0447,  0.7614, -1.2196, -0.5788,  0.4128,
          0.2822, -0.7087,  0.7638, -1.2023, -1.4040, -0.3361,  0.0961, -1.2491,
         -1.2159,  1.7288, -1.5975, -0.7892, -0.3213,  0.4886, -0.4395,  0.8248,
         -0.1356,  1.0946, -0.0798, -1.0341,  0.5240,  0.0456, -0.4374,  0.5594,
         -0.8723, -0.1566, -2.3145, -1.2582,  0.4562,  0.2723, -1.0719, -0.1717]])
44: 因   词向量: tensor([[-0.6953,  0.0299,  1.1689,  0.5407,  0.2593,  1.0880, -0.6120, -0.4362,
         -0.5349,  0.0470, -1.7298, -0.3189, -0.6521, -1.1419, -0.1377, -0.3708,
          0.0674, -0.0340, -0.6774,  1.3706,  1.4224,  1.3449,  0.3215, -0.3885,
          1.4160, -0.8970, -0.3351,  0.2710,  0.1199, -0.4192, -0.8231,  0.0205,
         -0.8621, -0.0056,  0.4288, -0.8688,  0.6278, -0.6215,  1.2195, -1.8778,
         -1.1621, -0.6641, -2.2388,  0.1523,  0.9739, -0.2387, -1.1108,  0.0185,
         -1.3954,  0.4345, -1.9215,  0.0101,  0.8398, -0.7043,  1.2207, -0.6346,
         -0.3100, -1.4357,  0.5465, -0.1911, -0.6763, -0.2377,  1.2261,  0.3085,
          1.0818,  1.4969,  0.5146,  0.3250, -0.8032,  0.7045, -0.0147,  0.1613,
         -0.6856, -0.0940,  0.7458,  1.2374,  1.1497,  0.0072, -0.6461, -0.9718,
         -0.7268,  1.5200, -0.2985, -1.9819, -0.7442,  1.6588,  0.2809, -0.0664,
         -0.4558, -1.3838, -0.1158, -0.9900,  0.3545,  0.1350, -0.3233, -1.0548,
         -0.6536, -0.0381,  1.4860, -1.0694,  1.1341, -1.5340, -0.7540,  0.6109,
         -0.3733, -1.9303, -1.0210, -0.3443,  2.2516,  0.0581, -0.0224, -1.3393,
         -0.5132, -0.3895,  1.2804, -0.6350,  0.5694,  0.7077, -0.8996, -0.2569,
          3.1786, -2.2239,  0.2082, -0.4805,  0.6633,  0.4823,  1.0565, -1.2659]])
2: 你    词向量: tensor([[-0.2350,  0.2923, -0.5940,  0.4420, -0.5620,  0.6781,  0.6996,  1.1685,
         -1.1202,  1.1702,  1.7431,  1.1335, -0.2978, -0.8452, -0.1611, -0.7057,
         -1.2757, -0.4136, -0.8584,  0.7088,  1.0133,  0.6883,  0.7639,  0.3339,
         -0.0689, -0.8740,  0.1080, -0.2372, -0.0766, -1.1628,  1.2577, -1.4728,
         -0.8391,  0.1434, -0.7532,  0.1123, -0.0730, -0.3895, -0.8914,  1.0943,
          0.9030,  0.6517,  1.9855, -0.5613, -0.9821, -0.0886,  0.6993,  1.1337,
          0.0435, -1.1503,  1.6857, -0.9903, -0.1018, -2.5759,  0.3399,  0.7758,
         -1.5326, -0.9689, -0.0901,  0.1434,  2.1109,  1.5606, -1.2908, -0.8750,
         -0.1149,  0.3210,  1.2538,  0.2164, -1.1185, -1.3347, -0.1046, -1.3265,
         -0.0519,  1.7280, -0.8752, -0.2027,  0.0870,  0.3137,  2.1226,  0.7773,
         -0.4965,  1.2673,  0.9419,  0.0753,  1.3247, -0.2009, -0.1344,  1.8694,
         -0.8257, -1.2295, -0.1927,  0.9116, -0.9511,  2.7437, -0.3050,  0.6188,
         -0.6865,  0.1427,  0.6941, -0.4649, -1.3865,  0.1717,  0.4214, -1.9276,
          0.1772,  0.2489, -0.8077, -0.8780, -0.4985,  0.4747, -2.3380,  1.7014,
         -2.1964,  0.3989,  0.0545,  0.6022, -0.4869, -1.9906, -1.0134,  0.2028,
         -0.0669,  0.2856, -0.4412,  0.8217,  0.0568,  1.1643, -1.0116,  1.9836]])
45: 而   词向量: tensor([[-6.9493e-01,  1.4062e+00, -3.1675e-01,  5.8409e-01,  2.9410e-01,
         -5.5122e-01, -6.2750e-01, -1.2793e+00,  6.2230e-01,  1.8255e+00,
         -1.5399e+00,  7.1456e-01,  3.0716e-03, -1.0304e+00,  7.4607e-01,
         -1.3288e+00, -5.4598e-01,  2.0768e+00, -5.0377e-01,  1.5654e+00,
         -1.1130e+00, -6.5534e-01, -5.2108e-01,  1.0062e+00, -4.0439e-01,
         -4.0440e-01,  1.0674e+00, -9.5448e-01, -2.7082e-01,  1.4654e+00,
         -2.8040e-01, -1.4891e+00,  6.3615e-01,  6.6646e-01, -4.0095e-01,
         -1.0941e+00,  1.9780e-02,  1.0787e-01, -1.5074e-01, -6.5446e-01,
         -5.3278e-01, -4.2440e-01,  4.4326e-01, -1.9796e+00, -2.3452e-03,
          1.1360e+00, -6.2523e-01,  2.4874e-01, -1.2869e+00, -1.2564e+00,
          1.8399e+00,  1.1310e+00,  3.7163e-01,  1.0387e-01,  1.9941e+00,
         -1.9027e+00,  5.3621e-02, -3.1132e-01, -4.8634e-01,  1.2258e+00,
          4.1567e-01,  8.8325e-02, -4.1522e-01, -7.3539e-01, -1.2774e+00,
         -6.7218e-01, -9.5278e-01,  1.8209e+00,  1.5850e+00, -1.4090e+00,
         -3.7985e-01,  4.8194e-01,  1.5726e+00,  1.3843e+00,  1.2500e+00,
          6.6419e-01, -5.8809e-01, -2.1640e-01,  1.2158e+00,  7.3180e-01,
          1.0677e+00,  2.6748e-01, -6.7863e-01, -3.5348e-01,  2.0592e-01,
         -1.6295e+00,  1.2518e+00,  6.7684e-02,  8.8990e-01, -1.4817e-01,
         -3.5291e-02,  1.1091e+00, -2.4658e+00,  8.8627e-01,  5.1475e-01,
          1.1680e+00, -9.7546e-01, -5.5057e-01, -3.8526e-01, -1.2595e+00,
          8.0320e-01, -1.1163e+00, -4.2267e-01, -1.5712e+00, -8.3920e-02,
         -7.5662e-01,  3.3516e-01, -1.0455e+00, -8.5412e-01, -1.0817e-01,
         -1.9216e-01,  8.4686e-01, -4.6614e-01,  6.8509e-01,  6.1812e-01,
         -1.9532e+00,  2.3169e+00, -1.3680e-01, -7.9031e-01, -2.6187e-01,
         -1.0526e+00, -1.5326e-01,  1.7926e-01,  3.3464e-01, -4.1420e-01,
          6.3608e-01,  1.5391e+00, -1.4365e+00]])
46: 香   词向量: tensor([[ 1.1219,  1.0796,  0.2386, -0.2531,  1.3683,  1.0109,  1.4057,  0.4779,
         -1.7352,  0.8844, -1.0220, -0.6492, -0.6238, -0.9067, -1.2073, -1.2844,
          0.1932,  2.4944, -2.6507,  1.5242,  2.0159,  0.8329, -0.1949, -0.0109,
          0.4642,  0.4089, -1.5732, -0.6178,  0.0168, -0.8314, -2.0872,  2.4771,
         -0.7312, -2.2930, -0.2236,  0.5033,  0.9182,  0.8936, -0.8301,  1.6399,
         -1.0809, -1.2183, -0.3412, -0.5223,  1.7513, -0.5539,  0.6528,  0.0027,
          1.8203, -0.9402,  0.1190,  0.3335, -0.5194,  0.3879, -0.6065,  0.2250,
          0.5431, -0.7531,  0.2786, -0.0649,  0.8879,  1.9610, -0.3204, -1.3830,
         -0.0650,  0.9430, -2.0940, -1.3006,  0.3104, -1.8551,  0.8262, -1.4165,
         -1.1421,  1.4812, -1.1354, -0.1728,  0.4486, -0.0232, -1.9880,  0.2007,
         -0.9809, -1.0533, -1.0997,  0.8863, -0.5470,  1.1782,  0.9364,  0.9233,
         -0.6922, -1.0484, -0.4710, -0.9735, -0.8595, -1.3355, -2.3149,  0.6993,
         -0.5502, -1.1625, -1.2600,  0.9010, -0.1639,  0.2649,  2.1328, -0.2760,
          1.5169,  0.0307, -1.7372,  0.7917, -0.1726,  0.6966, -0.6777,  0.2696,
         -0.5333, -0.1086, -0.2842, -0.7344, -0.2377, -0.2307, -0.7686, -1.1642,
         -0.7456, -0.8460, -0.9036,  0.0933, -0.5102, -0.2190,  0.0434,  0.5659]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
47: 试图  词向量: tensor([[ 3.8229e-02,  1.0295e+00, -9.8116e-01,  3.0016e+00, -8.3988e-04,
         -5.4871e-01,  1.6143e-01, -7.7370e-01, -4.2112e-01,  2.1031e-02,
         -1.9869e+00, -5.6874e-02, -3.0638e-01,  1.8294e+00,  1.5476e+00,
         -1.5998e-02, -1.3612e+00, -1.0680e+00,  9.1975e-01,  9.6268e-01,
         -4.1225e-01, -2.4728e-01,  8.7029e-01, -3.1911e-01, -7.3283e-01,
          6.1494e-01,  2.7506e+00,  2.5409e+00,  6.3492e-01,  5.7630e-01,
         -7.7426e-02,  8.4821e-01, -1.0945e-01,  1.0364e+00, -2.0155e+00,
         -2.4681e-01, -1.9374e-01, -2.0869e-01,  8.7123e-01, -6.9003e-01,
         -2.2480e+00,  1.2094e+00,  4.3536e-01, -8.7690e-01, -8.0195e-01,
          1.3994e-01, -1.4737e+00,  1.1885e+00, -8.2735e-01,  1.1662e-01,
         -2.6052e-01,  2.5670e-01,  9.9016e-01, -3.6616e-01,  1.4097e+00,
         -4.0346e-01,  5.5548e-01,  5.6929e-01,  1.6270e-01,  1.8525e+00,
          1.0757e+00,  3.4564e-01, -2.4647e-01,  4.0178e-01,  9.3586e-02,
         -2.0745e+00, -9.6670e-02,  1.2683e+00, -1.4990e+00,  2.9566e+00,
          9.4927e-01, -1.9397e-01,  1.7072e+00,  1.3692e+00, -1.1363e+00,
         -1.8812e+00, -4.4998e-01,  2.9471e-01,  8.6469e-01,  8.5077e-02,
         -7.3075e-01, -8.7080e-01,  1.0867e+00, -1.2369e+00, -4.6418e-01,
         -7.6873e-02, -1.4832e+00, -1.5348e+00, -2.6368e-01,  2.0422e+00,
         -1.4194e+00, -1.0408e+00, -6.6020e-02,  3.2093e-01, -1.3257e-01,
          5.0488e-01, -1.1369e+00, -7.6361e-01, -2.5426e-01, -1.0196e-01,
          6.7761e-01,  5.2637e-01, -8.7972e-01, -1.2195e-01,  1.5258e+00,
         -6.6660e-02,  3.2165e-02,  3.9270e-01,  1.2309e+00,  1.9312e+00,
         -4.9214e-01, -8.3518e-01, -2.4525e-01,  9.7059e-01,  1.3650e+00,
         -6.3579e-01,  5.3070e-01,  1.8185e-01, -1.5820e+00,  3.4072e-01,
         -1.2839e+00,  8.3954e-01, -1.7604e+00, -6.7730e-01, -3.8595e-01,
         -4.6726e-01,  5.9705e-01, -9.1093e-01]])
48: 让   词向量: tensor([[ 0.1047, -0.1963, -0.5827,  0.2373,  0.5354,  1.1712,  0.4129,  0.3905,
          1.7455, -0.1996,  1.4604, -0.1104,  1.5858, -0.2527, -0.6230,  0.4800,
         -0.7811,  0.2958, -0.3782,  1.9233, -0.5916, -0.3274, -1.5021, -0.0400,
         -1.7086, -1.2303,  0.3489, -0.2678,  0.0236,  0.4103,  0.6926, -0.3335,
         -0.0477, -0.4302,  2.1077, -0.1851,  0.8022, -0.1936, -1.5385, -0.9973,
          0.3996, -1.0661, -0.5265,  0.9906,  1.3254,  0.4078,  1.6247, -0.3208,
         -0.5164, -1.8549,  1.9178,  0.6265, -0.5813, -0.4273, -1.3287, -0.7632,
          0.0737, -0.5155, -0.2682,  1.9832, -0.7008, -1.9192, -0.1252, -1.5195,
         -0.1937, -0.5278,  0.8634, -0.0307,  0.0053,  1.1085, -0.4354,  1.0311,
         -0.3634,  1.1479,  0.5621,  1.8091,  0.8000, -1.5153, -0.0878,  0.5621,
          0.3949,  1.5060, -0.3300,  0.4974, -1.6473,  1.9393,  0.7104, -0.7937,
         -2.3827, -0.3346,  0.2019, -0.5378,  1.3844,  0.7436, -2.1666,  2.0400,
          0.6024, -0.2300,  0.8634,  0.6597,  1.5599, -1.2148, -0.7414,  0.2471,
         -1.4901,  0.9992,  0.9838, -0.0489, -0.4885, -0.4100,  0.1226,  0.5899,
         -0.3981,  0.2456, -0.2408, -1.7554,  0.8440,  0.5517,  0.6177,  1.9538,
         -0.1266,  0.7740, -0.3234,  1.0270,  0.2702, -0.6555, -0.0128,  1.1648]])
49: 夕阳  词向量: tensor([[-0.6004,  0.9376, -0.6297, -1.8173,  0.2103,  0.3722,  0.0192,  0.9139,
          0.5123, -1.6350, -1.4789,  0.2643,  1.5317,  0.8034, -0.0666,  0.4330,
          0.2521,  0.6076,  0.4397, -1.1878,  0.6810, -0.4961,  0.6582, -1.2506,
         -0.9845, -0.7020, -0.5939,  0.8869,  0.8704, -1.1969, -0.7378,  0.4396,
          2.2369,  0.7673, -2.3626, -0.2410, -0.1081,  1.3425, -0.2445, -0.9309,
         -0.5149, -0.3644,  0.8627,  0.3312, -1.0202, -0.1720, -0.7266, -1.8455,
         -1.8430, -0.8775, -1.7141, -0.5157,  0.0070, -1.5449,  1.2689, -1.0665,
         -0.9434, -0.0797, -1.0266,  0.4979, -0.9363,  1.4508,  1.1772, -0.3139,
         -0.5204, -0.2885,  0.1240, -0.0211, -2.3010,  0.8195, -0.2835,  1.2481,
         -0.5358, -0.8594, -0.4159,  1.3001, -0.6774,  2.3530, -1.6556,  1.9768,
          0.3301,  1.6243, -1.2789, -0.8119,  0.9700, -0.2757,  1.4842,  0.0566,
         -0.4246,  1.4038,  0.9694,  0.1432, -0.0601, -0.7541,  0.9335, -0.7924,
          1.2861,  1.3255,  0.5303, -0.3681, -0.5266, -1.3112, -0.1385, -0.5437,
         -0.1600,  0.2397, -1.5492, -0.1492,  1.2562, -0.0595,  0.2199,  0.5822,
         -0.3988, -0.0322,  1.8986, -0.9918,  0.9039, -1.7710, -1.4276,  1.7922,
          1.1502, -2.5430, -0.1372,  1.4500, -0.3768, -0.4091, -1.5363,  0.4002]])
50: 飞翔  词向量: tensor([[ 1.0860, -0.0171, -0.6277, -1.1933,  0.9315, -0.7330,  0.8131,  0.1651,
          0.4671,  1.8656, -0.4305, -1.0249,  2.9707,  1.3919, -0.6975, -1.8236,
         -1.0667,  1.5667, -0.9691,  0.2355,  0.1622, -0.5192,  0.0356,  0.3255,
          0.3883, -0.6321, -0.5643,  0.2612,  0.5231, -2.6157, -1.4175,  1.1954,
          1.7983, -0.3155,  0.6007, -0.2746, -0.7162, -0.1186, -0.2207,  0.6713,
         -0.5339,  0.4534,  0.5201,  0.9344,  1.6918, -1.7041, -0.4986,  0.1152,
          0.4424, -1.0363,  0.0898,  1.0369, -0.6468, -0.9246, -0.2190,  0.0517,
         -0.9905, -0.5032,  0.8691, -0.3064, -0.9427, -0.1224, -0.5199, -0.3677,
         -1.7578, -0.3239, -0.5745,  2.1304,  2.5637,  0.0856, -0.5059,  0.2896,
          1.3139, -1.7180,  0.0164, -0.7947,  0.1157,  0.4066,  1.0226,  0.9724,
          1.0858, -0.5026,  1.0933, -0.7102, -0.9489, -0.5639, -0.6002, -0.2920,
          1.4527, -0.6295,  1.3500,  0.6058,  0.9799, -0.4328,  0.1221, -0.9199,
          0.6476, -0.5325, -1.3911,  1.7790, -1.3404, -0.3926, -0.0288,  0.1779,
          0.6804,  1.3036,  0.8603,  0.4150,  0.6042, -0.6114,  1.3965, -2.1026,
          0.4287,  1.1885,  1.7315, -1.3131,  0.4715,  0.2487,  0.5676, -0.6143,
         -1.0070,  0.9936, -0.0798, -1.1731, -1.6360, -1.3797, -1.1460, -0.6632]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
51: 带领  词向量: tensor([[-0.3883,  1.4575,  2.0290, -0.8347, -0.5549, -0.4177,  0.9295,  1.0170,
         -0.6016,  0.4783, -0.8574,  0.3708, -1.2610, -0.8413,  0.9271,  0.3631,
         -0.8457,  0.1038, -1.3275,  0.2564, -0.0925,  1.5057, -0.4423, -1.3217,
         -0.9225, -1.1700,  0.6291,  1.5080, -0.3643, -0.8193,  1.8530,  0.8711,
         -1.9185, -0.8187,  0.7976,  1.1875, -0.7883,  0.7925, -0.7433,  0.2557,
          0.9899,  0.5820,  0.9995, -0.0171, -0.2620,  0.2623,  0.5431, -0.7220,
         -0.0887, -0.2825, -0.7457, -0.5655, -0.5712, -0.2949,  1.7468, -0.8723,
          0.1218, -0.4338, -1.5607, -0.1263,  1.4716,  0.1932, -1.9922,  0.2615,
          0.7598, -0.5381,  1.3246,  2.7312,  0.2112,  1.1132, -0.2877, -0.8743,
          0.0557,  0.6472,  0.0501, -2.3401,  0.3528,  0.2412,  0.3257,  0.2621,
          0.7255,  2.1305,  0.6389, -0.4104, -0.4304,  1.1592,  0.1603,  0.3825,
          0.2950,  0.0406,  0.7059,  0.6141, -1.3077,  0.4607, -0.3397, -0.6514,
         -0.4276, -1.3638,  0.6839,  0.2592, -0.2928,  0.2293, -0.4305,  0.9677,
          2.0352, -0.2551,  0.4089,  1.4816, -1.1304, -0.4020, -0.4308,  1.0968,
          0.6394, -1.0796, -1.0582,  1.2715, -0.1240,  0.4402, -0.8747,  0.0545,
          0.4919, -1.9369,  0.8893, -1.1005,  0.9882,  0.3336,  0.8308,  1.3954]])
2: 你    词向量: tensor([[-0.2350,  0.2923, -0.5940,  0.4420, -0.5620,  0.6781,  0.6996,  1.1685,
         -1.1202,  1.1702,  1.7431,  1.1335, -0.2978, -0.8452, -0.1611, -0.7057,
         -1.2757, -0.4136, -0.8584,  0.7088,  1.0133,  0.6883,  0.7639,  0.3339,
         -0.0689, -0.8740,  0.1080, -0.2372, -0.0766, -1.1628,  1.2577, -1.4728,
         -0.8391,  0.1434, -0.7532,  0.1123, -0.0730, -0.3895, -0.8914,  1.0943,
          0.9030,  0.6517,  1.9855, -0.5613, -0.9821, -0.0886,  0.6993,  1.1337,
          0.0435, -1.1503,  1.6857, -0.9903, -0.1018, -2.5759,  0.3399,  0.7758,
         -1.5326, -0.9689, -0.0901,  0.1434,  2.1109,  1.5606, -1.2908, -0.8750,
         -0.1149,  0.3210,  1.2538,  0.2164, -1.1185, -1.3347, -0.1046, -1.3265,
         -0.0519,  1.7280, -0.8752, -0.2027,  0.0870,  0.3137,  2.1226,  0.7773,
         -0.4965,  1.2673,  0.9419,  0.0753,  1.3247, -0.2009, -0.1344,  1.8694,
         -0.8257, -1.2295, -0.1927,  0.9116, -0.9511,  2.7437, -0.3050,  0.6188,
         -0.6865,  0.1427,  0.6941, -0.4649, -1.3865,  0.1717,  0.4214, -1.9276,
          0.1772,  0.2489, -0.8077, -0.8780, -0.4985,  0.4747, -2.3380,  1.7014,
         -2.1964,  0.3989,  0.0545,  0.6022, -0.4869, -1.9906, -1.0134,  0.2028,
         -0.0669,  0.2856, -0.4412,  0.8217,  0.0568,  1.1643, -1.0116,  1.9836]])
52: 我   词向量: tensor([[ 1.8025, -0.8686,  0.6503,  1.3381,  0.0555,  0.6407,  0.0161,  0.5962,
         -2.1178,  0.9846, -0.1072,  1.3838,  0.8264, -1.4054,  0.2844, -0.2970,
         -2.3557, -0.5851,  0.1094, -0.5116, -1.8826, -1.1737,  1.0207,  1.2605,
          1.6016, -0.4241,  0.9683, -1.0203,  0.2468,  0.4037,  1.1892,  0.5581,
          1.0928,  0.2257,  0.7151, -1.2975, -0.4777,  0.8343,  0.7666,  0.9375,
         -0.2058,  1.6071, -1.5055,  1.1093,  0.5306,  0.5420, -0.6054, -1.3755,
         -0.8689,  0.7478, -0.9576,  0.0944,  0.0334, -1.0172,  0.7365,  0.3529,
          1.0343, -1.5456,  0.5741, -0.0613,  0.8689,  0.7043, -2.2342,  1.3287,
          0.4374, -0.2889, -1.6983,  1.7067, -0.9939, -0.2796, -0.4290, -0.4194,
          1.0979, -0.5970, -0.9135,  0.4163,  1.6215,  0.1321, -0.4211,  0.1524,
          1.1856,  0.3440,  0.5450, -0.0427, -1.0537, -0.5387, -0.1554,  0.5156,
          1.3124, -0.7575,  0.0543,  0.4914, -0.7407,  0.5013, -0.1477, -0.7364,
          2.0451, -1.9390, -0.9945, -0.4166, -2.1268,  0.7785, -0.7775,  0.7935,
         -0.7087, -0.9547,  0.8181,  0.2678,  0.0905,  0.9333, -0.6942,  1.2687,
          1.4517,  0.6902, -0.5689,  1.0928,  0.6622,  1.2018, -0.5590, -0.6284,
         -0.4608,  0.9066, -1.3882, -1.0355, -0.6040, -0.8719, -0.2974,  2.1041]])
53: 环绕  词向量: tensor([[ 2.1902e-01, -1.1552e+00, -1.8424e-01,  3.3614e-01, -3.8256e-01,
         -1.1324e+00, -6.7924e-02, -5.9995e-01,  6.1576e-02, -1.0614e+00,
          4.6223e-01, -1.1970e+00,  1.1080e+00, -1.8975e+00, -1.6733e+00,
         -7.9665e-02, -8.5991e-01, -9.1305e-01, -3.2379e-01, -2.4269e-01,
          1.7524e+00, -1.2605e-01, -1.1945e+00,  5.8631e-01, -5.3558e-01,
          5.2792e-01, -1.1576e+00,  6.4780e-02, -6.7487e-01,  7.4069e-01,
          2.1513e+00, -7.9131e-01,  4.3649e-01, -4.6189e-01, -8.5121e-01,
         -2.4487e-01, -1.5749e+00, -1.1254e+00, -7.6424e-01, -1.6875e-02,
          8.4802e-01,  6.9762e-01, -8.4007e-02,  1.5265e+00,  1.7715e+00,
         -1.3288e+00, -9.2405e-01,  3.3903e-03, -3.5675e-02, -1.0754e+00,
          3.8780e-01,  1.2380e+00, -1.5078e+00,  1.4308e-02, -1.8832e-01,
          2.4368e-01,  1.6547e+00,  3.3784e-01,  6.2146e-01, -2.0486e-01,
          2.9040e-01,  2.3162e+00,  1.3580e+00, -1.5030e+00, -3.1261e-01,
          2.5586e-01,  3.7365e-01,  6.7240e-01, -1.4438e-02,  6.4064e-01,
         -8.4326e-01,  4.9617e-01,  3.2818e-01, -2.4743e+00, -1.1754e+00,
         -2.2826e-01,  2.0747e+00,  3.5032e-01,  9.2976e-02,  5.0810e-01,
          3.9344e-01,  1.0260e+00, -2.1320e-01,  6.9975e-02,  2.4769e+00,
         -3.3605e-01,  1.5252e+00, -8.1502e-02,  7.5484e-01,  2.8961e-01,
          9.4699e-01,  5.1192e-01,  2.2573e+00, -1.2976e+00, -6.8307e-01,
         -5.0647e-01, -9.5794e-02,  9.7939e-01,  9.8515e-01,  1.1481e+00,
          1.0263e+00, -1.4036e+00,  1.1095e+00, -1.0258e+00,  1.7887e-01,
         -1.8991e-01,  1.7981e+00, -1.5916e+00,  9.0513e-01,  8.2632e-01,
         -1.2119e+00,  7.6358e-01,  1.8939e-01,  5.4378e-01,  4.9077e-01,
         -9.7766e-01,  5.6718e-01, -4.8325e-01,  9.4810e-01, -6.4625e-01,
          2.1275e+00, -2.6082e+00,  4.6068e-01, -9.4026e-01, -1.8495e-03,
          7.4016e-01, -1.3644e+00, -9.7325e-01]])
54: 大自然 词向量: tensor([[ 1.0683e+00, -9.3921e-01,  1.0142e+00,  5.2375e-01, -1.6918e+00,
         -1.3720e+00, -2.8962e-01, -4.4843e-01, -1.4024e+00, -7.2348e-01,
         -1.6988e+00,  2.6401e-01, -1.3191e-03, -5.3966e-01,  1.2056e+00,
         -1.2444e+00, -8.3017e-02, -4.6160e-03,  1.0160e+00,  5.7973e-01,
          8.4230e-01, -1.1997e+00,  3.1302e-01, -7.8104e-04,  1.4088e-01,
         -9.4516e-01,  1.1195e-01,  9.8150e-01,  4.8767e-01,  4.8473e-01,
         -6.9974e-02,  1.1046e+00, -9.6830e-01, -1.2903e+00,  1.0750e+00,
         -1.3531e+00, -3.2607e-01,  1.4716e+00,  1.3152e+00, -1.0358e+00,
         -4.1777e-02,  8.5979e-01,  7.0251e-01,  4.8289e-01,  2.6085e-01,
          7.8900e-01, -5.6025e-02, -1.3694e+00, -1.4287e-01, -7.6493e-01,
          9.9712e-01, -1.2491e+00, -1.2640e+00,  8.3255e-01,  2.3806e-01,
         -2.4682e-01,  1.4890e+00, -2.1768e+00, -1.1718e+00, -1.2710e-01,
         -7.2177e-01,  1.6948e+00, -3.6733e-01,  2.4117e+00, -1.2189e+00,
         -1.0218e+00,  8.6482e-01,  1.1552e+00, -9.7631e-01,  1.7594e+00,
         -3.4284e-01,  3.7660e-01, -1.5496e+00,  4.1770e-01,  1.4202e+00,
         -3.3451e-02, -1.0973e+00, -7.3886e-01, -1.1802e+00,  2.7324e-01,
          1.1071e+00, -1.8545e-01, -1.0871e+00, -3.2923e-01,  8.6681e-01,
          2.2645e+00,  6.7991e-01,  7.6886e-01,  8.8457e-02, -7.2791e-01,
          1.0182e+00, -1.7361e+00, -3.4060e-01,  3.0723e-01, -5.5604e-01,
         -6.3626e-02, -2.0292e-01,  1.8210e+00,  5.6976e-01, -3.8184e-01,
          3.1810e-01, -1.1195e+00, -2.4723e+00,  9.2755e-01, -4.2846e-01,
          5.0195e-01, -3.5629e-01,  1.1201e+00, -1.7522e+00, -1.1405e-01,
         -1.1771e+00,  4.1570e-01, -2.2039e-01,  7.2794e-01,  6.5139e-01,
         -4.2230e-01, -4.1998e-01,  1.1662e+00,  2.7355e-02, -1.2218e+00,
         -7.0014e-01,  2.1131e+00,  6.1906e-01, -2.2585e-01, -3.8449e-01,
         -2.2723e-01, -4.5542e-01, -1.1120e+00]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
55: 迎著风 词向量: tensor([[ 0.2499, -0.9195, -2.0798,  0.8443, -0.4590, -0.2433,  0.4116,  1.4193,
          0.1332, -0.1165, -0.6010, -0.3951,  0.7606, -1.3181,  0.2098, -1.1948,
          0.2119, -0.1856,  0.5986,  1.0093, -1.6948, -0.9851,  0.9495,  0.3580,
         -0.0412, -0.6933,  0.3507,  0.5312, -2.0586,  0.0343, -0.0656,  0.1630,
          1.2536, -0.0250,  0.8471,  0.3254,  0.4763,  0.6172,  0.0852,  0.0637,
         -0.4052,  0.5236, -0.2595, -1.4127,  0.3243,  1.0533, -0.6825, -1.5045,
         -0.9738, -1.9627,  0.7090,  0.0586, -0.8406, -0.9009, -0.6829, -0.9942,
          0.0103,  0.1358,  0.6260, -0.0610,  1.4292, -1.4707, -1.2501,  0.1482,
         -1.9348, -0.7603,  0.2080, -1.4380, -0.2337,  0.5236,  0.3099, -0.0222,
          0.1745,  2.7300, -1.4230, -0.4661, -0.7483,  2.5051,  0.8559, -0.1612,
          0.8224, -0.2808,  0.3730, -0.9974,  0.6265,  1.1285,  0.1511,  0.0687,
          0.7169,  0.3940, -0.0870,  0.4539, -1.6034, -0.0756,  0.1008, -1.5667,
          0.2044,  0.2164,  0.4385, -1.1896, -0.7260,  0.0813, -1.5283, -0.8356,
         -0.5925, -0.2488, -0.2587, -1.6830, -1.5480, -0.3825, -0.5161, -0.5260,
         -0.7144, -0.5617, -1.1504, -0.0983,  0.9098,  0.5436, -0.6765, -1.9885,
         -2.2751, -0.4951, -0.6814,  0.6681, -1.1405,  0.7472,  0.0320,  0.8300]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
56: 开始  词向量: tensor([[-1.9813,  1.6995,  1.1226, -1.1644,  0.5912,  0.1666, -1.0282,  1.3264,
         -0.4648, -0.0262,  1.7921,  0.3861,  1.2850, -0.5048, -0.1850, -1.2177,
         -0.9231, -0.4529,  0.7043, -1.9624, -0.9191, -0.4489,  0.7742,  0.0458,
         -0.4288,  0.5045, -0.4517, -0.0529, -0.6371,  0.3220, -0.2698, -1.5022,
         -1.3722,  0.7447,  0.1231,  0.9082, -0.3852, -0.6957,  0.4795, -0.3938,
          0.2775, -1.2321, -0.3383,  0.7813,  0.0436, -1.2526, -0.6505,  0.3326,
          1.0836, -0.4308, -1.2012, -1.0896, -1.2444,  2.0645, -0.2010,  1.4258,
          0.1280,  0.5159,  0.0596, -0.2161,  0.2984,  0.4174, -0.0073,  1.3804,
          0.1315,  0.7714,  0.9009, -0.4024,  1.0126,  1.4795,  0.9897, -0.0254,
         -0.9798, -0.4357,  2.2943, -1.0560,  1.2949, -0.8752,  1.4327,  1.0656,
          0.1439, -1.4196, -1.4354, -0.7374,  0.0495,  1.0598, -0.3429,  0.2520,
         -1.1802, -0.9050, -0.7626, -0.5806, -0.9929, -2.2615, -0.0110, -0.7846,
          0.2553, -0.2644, -0.5114, -0.5074, -0.3472,  0.1222,  0.3443,  0.3440,
         -1.3284, -0.6892,  0.5428,  0.0414, -0.1834, -0.3867, -2.0045,  0.6607,
         -0.6262,  1.8186, -1.2601, -0.1855, -1.2118,  1.4943,  0.5222, -2.3380,
          0.6423,  0.2073, -1.1112,  0.8694,  1.3488, -1.7096, -2.0201, -0.9811]])
57: 共渡  词向量: tensor([[ 1.1552, -1.1775, -0.7923, -0.8759,  0.3838, -0.3569,  0.2196, -1.7299,
         -0.2527, -0.4146, -0.2309, -0.0932, -1.3646,  0.0742,  0.0528,  1.2435,
          0.2058,  1.0656,  0.1760, -0.0908,  0.2878, -0.5905, -0.8570, -1.0456,
          0.0119, -0.1301, -0.5770, -0.7324, -1.2146, -0.4203,  0.3345, -1.6111,
         -0.0893, -0.5048, -0.4912,  0.5011, -0.6233, -0.0686,  0.5077,  1.3853,
         -1.1493, -0.6771, -0.0249,  0.0469, -1.8951,  0.7383,  1.6796,  0.1959,
         -1.0561, -1.3896, -1.5098,  2.3460,  1.8851,  0.6651,  0.7328,  0.4741,
         -0.4156, -2.0029, -0.0087,  1.3089, -1.1811, -0.3713,  1.4896, -1.9756,
         -0.2270,  0.7772, -1.0457,  0.8554, -0.3493, -1.0754, -0.3900,  0.0935,
         -1.2546, -1.4160, -0.4934, -1.6591, -0.8026, -0.4168,  1.4469,  1.1436,
          0.5042, -0.8564,  1.9937, -0.2030, -0.7135, -1.4389,  0.9389,  0.1246,
         -1.0682,  2.0665, -2.5335,  2.5368, -0.9056, -0.5825,  0.5129,  0.6345,
          0.1575, -0.3034, -0.7676, -1.3009,  0.6037, -0.5790, -1.8223, -0.7235,
          0.9397, -0.3880, -0.4059,  0.9193, -0.3312,  0.2401,  0.9551, -1.3676,
         -0.2662, -0.9645,  1.3275, -0.3785,  0.0332, -0.4419,  0.9355,  1.4195,
         -1.2115,  1.2054,  2.5421, -0.3062, -1.9236, -0.5395, -0.0240,  0.7995]])
58: 每   词向量: tensor([[ 0.3498, -0.7574,  0.1146,  0.7873,  1.4814, -1.2129, -0.3470,  1.5027,
         -0.2193, -1.9263,  0.0346, -0.5626, -0.3347,  0.5228, -0.6182, -0.7035,
         -0.3006, -0.8527,  0.3731,  0.0857, -0.0111, -0.8429, -1.6461,  0.3679,
         -0.3584,  0.9093,  2.0222, -1.1867,  2.0389,  0.0766, -1.0236, -0.9392,
         -0.0163, -0.1390, -1.1153,  1.8077,  1.4790,  0.6615,  0.1883, -1.0539,
          2.0340,  0.7649,  0.0168, -0.9907, -1.6050, -0.3988, -0.8727,  0.5305,
         -0.6364,  0.2739,  0.7177, -2.1755, -1.6382, -1.4612,  1.9361,  0.0580,
         -1.2769,  1.1145,  0.3545, -0.9117, -0.2648,  1.2646,  1.9668,  0.4406,
          0.8857, -0.3670,  0.8295,  1.4161, -0.2115,  1.2174,  0.5693, -1.2825,
          1.0954, -1.2001,  0.6513, -0.3302, -1.2100, -2.3221,  0.4044,  0.0423,
         -0.9381, -0.4300,  2.2154,  1.0064,  0.5278,  0.2070, -1.0909, -2.0609,
         -0.5837,  2.0414, -1.2969, -0.0257, -0.8994, -0.8459, -0.7661,  0.9830,
         -0.9493,  0.3878,  1.7131, -1.0839,  0.3617, -1.7164, -0.5890, -1.4442,
         -0.5854,  1.5730, -0.6862,  1.0519, -1.9228,  0.3219,  1.0994, -1.8571,
          0.8783, -0.3197,  0.0278,  1.1004,  0.0468, -0.8312,  0.2939, -0.1949,
         -0.2218,  1.3453,  0.1781,  0.2764,  1.5048,  0.7907, -1.4415, -0.5297]])
59: 一天  词向量: tensor([[-0.8323,  0.0881, -1.4882,  0.2288, -1.0547,  1.1075, -0.1441,  0.2287,
          0.8294, -1.3625,  0.9649,  0.5535, -0.7352,  0.1774, -0.7410, -1.4113,
          0.9171,  1.3320,  0.2866,  0.1871,  0.7052,  1.2598,  0.3351,  2.0226,
         -1.3257, -1.3111,  2.5196,  0.1810,  0.6007, -0.9601,  1.2443, -1.5912,
          0.2706, -1.9888,  0.0807, -1.1416,  1.5431,  0.5763, -0.4852, -0.5902,
         -0.8565, -1.2463,  1.2020,  0.3245,  0.8880,  1.7908, -0.5500,  0.2925,
          0.6405,  1.2001,  0.2597,  0.1210,  1.8376,  0.5919, -0.9829,  0.0814,
          0.7686, -0.8528,  0.8874, -1.2020,  1.0796,  0.1069,  1.1454,  1.5961,
          0.9683, -0.6176,  1.5075, -0.0719,  0.1401,  1.6648,  1.6374,  0.0056,
          0.6043,  0.8292, -0.7032, -0.2443,  0.8741, -0.2997,  1.5568,  1.2950,
         -1.4252,  0.6444, -0.9421, -0.6760, -0.5903,  0.0040,  0.0740, -0.1053,
          0.0359,  1.1091,  0.8509, -1.5936, -1.1683, -1.0063, -0.1447, -0.3768,
         -0.0526, -0.2548, -0.2461, -0.6924, -0.5115,  0.3421,  0.9276, -0.4238,
          0.5287,  0.2878,  0.4261, -2.0163, -0.9782,  0.6345, -0.3501,  0.2344,
          1.3634,  1.1329, -2.0690,  0.7777, -1.3949, -0.7385,  1.0592,  0.7805,
         -1.1326,  0.1079, -0.3565, -0.0959, -1.0551,  1.1710,  0.3118, -1.5953]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
60: 手牵手 词向量: tensor([[-0.4457, -0.0111, -0.1142, -0.3385, -2.3170, -1.1889, -0.4656,  1.8851,
          1.0001, -0.9519,  0.9699,  0.2183,  0.6482, -1.7934,  0.1949, -0.2373,
         -0.4917,  0.0193, -0.2512, -0.1193, -1.0027, -0.0518, -0.1406, -0.1449,
          0.2086, -0.2187, -0.9120,  0.1278, -0.2654, -0.9425, -0.7463,  0.6436,
         -2.1115,  0.1178,  1.7578,  0.0539,  0.1830,  0.8112, -0.0274,  1.0397,
         -1.3360,  1.3458, -1.3802, -1.0181,  0.4262, -0.9126, -0.9357,  0.2789,
         -0.9752,  0.9468,  0.1352, -0.0782,  1.3297,  2.1012,  0.5217, -1.5189,
          1.4051,  1.1851, -0.7222, -0.4523, -0.9668, -1.7462, -0.1036, -0.0657,
          0.7856,  1.4936,  0.9012, -0.4188,  0.0092, -1.1457,  0.6428, -0.2174,
          2.0091, -1.0033,  2.2029,  0.1472, -0.4140,  1.4386, -0.8736,  0.6306,
          0.9984, -1.6063, -0.3681, -0.8818,  1.8783, -0.5745, -0.2927,  2.2076,
         -0.9706, -1.5232, -0.3766,  0.3183, -0.0388,  2.2997, -1.0957,  1.2374,
          1.7551,  1.2685, -0.5895, -0.6288,  0.3892, -1.2646,  0.4644, -0.3824,
         -0.0753, -1.0889,  0.1276, -0.9911, -0.3899,  1.1059, -0.1128,  0.4696,
         -0.0387, -0.3349,  0.7895, -0.4671, -0.5814, -1.0417,  0.7999,  0.2012,
         -2.0221,  0.1848,  0.2324,  0.8634,  1.2771,  0.5084,  0.3314, -0.4662]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])
0:      词向量: tensor([[-1.0558,  0.8881, -0.9850,  0.8188, -0.7008, -0.0922, -0.2241,  0.4969,
         -1.0668,  0.4412,  0.7892,  1.5448,  0.9501,  1.0494,  0.2578,  0.2669,
          1.4082,  0.5511,  1.3676, -0.4447, -0.9770, -1.2668,  0.4750, -0.3019,
          0.5630, -0.2293,  0.2125,  0.2311,  0.2486, -0.1571, -1.7642, -0.1463,
         -3.0483, -2.3720, -1.3424, -0.1577, -0.0171,  0.8787,  1.5240,  0.4730,
         -0.8506, -0.0183,  1.1694,  1.2187,  0.5417,  1.3164,  1.8620,  0.4319,
         -0.2337,  0.3830,  1.0625,  0.9880,  0.5470, -0.3907, -1.1378,  0.1881,
          0.8776,  0.2353,  0.3081,  1.1402,  1.0400, -0.4366, -0.9093,  0.3939,
         -0.6285,  1.3242,  0.6147,  1.7434,  0.2010,  1.4402,  0.5377, -0.1547,
         -0.5641,  0.8100,  1.5759,  0.3668,  2.9535,  1.2819,  0.5410, -0.3859,
          0.0836,  0.3964, -0.1896,  0.6245,  1.9583,  0.2600, -2.2688,  0.7577,
          1.0525, -2.5902,  1.4733,  0.5291, -1.9547, -0.6918,  1.7990, -0.7484,
          1.2813, -0.3554,  1.5658, -0.5579, -1.4720,  0.1699,  0.3927,  0.9757,
          0.5506, -1.0921,  0.6403,  0.3171,  1.4954, -0.6224,  0.2379, -1.1242,
          0.2876,  0.7108, -0.7549,  0.5265, -0.1823,  1.0296, -0.0220,  0.9025,
         -1.8766, -0.7134, -1.2855,  1.8341,  0.6500, -1.3963, -0.8693,  0.0550]])
61: 一步  词向量: tensor([[ 0.9854, -1.2690,  0.6755,  0.9791, -0.7692, -0.3396,  0.7444, -0.1841,
          0.5338, -0.7630,  0.7404, -1.3930, -0.7798, -0.5989, -1.2273,  0.5384,
         -2.8233,  1.9800,  1.8217,  0.6808,  0.9290, -0.9703,  0.0657, -1.1967,
         -0.4422,  0.2280,  1.2710, -1.2026,  0.6665,  0.5191, -0.9456,  1.9234,
         -2.4274, -0.2036,  0.0981, -0.0781,  1.3622,  1.3070, -0.5892,  1.3786,
         -2.0082, -0.2287, -0.4984,  0.5516, -0.9018, -0.9672,  0.6945, -1.7003,
         -0.0059, -0.7846,  1.2262,  0.8687,  1.8092, -0.9282, -0.4748, -1.0091,
          2.1235, -0.4453,  1.4294,  0.0225, -0.5111,  2.0459, -1.4678, -1.2538,
          0.3284, -1.7567, -1.9918,  1.4049,  0.4875, -0.7923, -0.4132,  0.2315,
          0.7019, -0.6254, -0.0726,  1.5229,  0.1685, -0.8175, -0.3895,  1.4473,
         -0.0698,  1.7641,  0.2572, -2.3368, -1.4207,  0.0671,  0.0591, -0.8647,
          2.0336, -0.8095, -0.5938,  0.9260,  0.0963, -1.6361, -1.2757, -0.8129,
         -0.5823,  0.1888,  1.2362, -1.2889, -0.1477,  0.2733,  0.3116,  0.4198,
         -0.9686,  1.3732,  0.7068, -0.0575, -1.3484,  0.4544, -1.2748, -1.1468,
          0.4440,  0.5673,  0.9180,  1.2850,  0.4027,  0.2936,  1.3631, -1.0128,
          0.6255,  0.7762,  0.7725,  0.7121,  0.8912,  1.0394,  0.4000,  0.2730]])
62: 两步  词向量: tensor([[-1.4841, -0.4666,  0.7924,  0.1195,  0.7606,  1.0563, -0.8920, -1.2274,
         -0.5929,  0.4674, -0.1980,  1.0637, -1.2775, -1.4201,  0.5583, -1.0308,
          0.1844,  0.0704, -0.1867,  1.3427,  0.3063,  0.0943,  0.0689,  0.4293,
          0.8627, -1.7344, -0.5952,  1.9933, -1.1489,  0.1377, -0.3827,  0.6335,
          0.3720, -0.0605,  1.7543,  0.2534, -1.0263, -0.8452,  0.8373, -0.8766,
         -1.9627, -1.3624,  0.2630, -0.2924, -0.2172, -0.4633,  0.8443, -0.8749,
         -0.7271, -0.4718,  1.0398,  0.1794, -2.0009,  1.1092, -1.0449, -0.6830,
         -0.6373,  0.0326, -1.9863,  1.4530, -1.1634, -1.9569,  0.5194,  1.4223,
         -0.5422,  0.5160, -0.2853, -0.7955, -2.3985, -0.0743, -1.1329, -0.2955,
          0.3917,  2.6188,  0.0035,  0.5957,  0.3004,  0.1322,  0.1627,  0.7105,
         -1.2862, -1.7003, -1.4462, -0.0824,  0.4808,  1.0575, -0.5548, -1.1678,
          0.5736, -0.9303,  0.4457, -0.1778, -0.6941,  1.2100,  0.6334, -1.8079,
          0.2552, -0.3786, -1.1633,  1.5506,  0.8175,  0.6522,  0.4500,  0.3415,
          0.0154, -0.7068, -0.1257,  0.0550,  0.9416, -0.7952, -0.8868, -1.1407,
         -0.9140, -1.6486,  0.7874,  0.5624, -0.4908, -0.3209, -0.0323, -0.5650,
         -0.9341,  0.5328,  0.0654,  1.6518, -1.4184, -0.7103,  0.8351, -0.1445]])
63: 三步  词向量: tensor([[ 1.8932e+00,  9.1970e-01,  2.7027e-01, -2.3908e+00, -6.1062e-01,
         -6.3633e-01,  1.4612e+00,  2.3411e+00,  1.5788e+00, -3.1986e-01,
         -1.2401e+00,  8.2538e-01,  2.3567e+00,  4.0510e-02, -1.2214e+00,
          1.2295e-01, -5.2664e-01,  4.5525e-01,  5.6684e-01,  5.8943e-01,
         -1.5617e+00,  5.9794e-01,  1.3509e+00, -9.8100e-01,  4.8033e-01,
          4.5032e-01, -2.1695e-03,  3.1046e-01,  1.6488e+00, -7.9855e-01,
         -4.8367e-01,  5.5191e-01,  3.0998e-01,  6.7324e-01,  1.9096e+00,
         -1.0135e-01, -1.2919e+00, -1.4905e-01, -5.3759e-01, -2.9332e-02,
         -1.8953e+00, -1.8282e-01,  1.4832e-01, -4.2072e-01,  3.1158e-01,
         -1.0317e+00, -3.2119e-01,  5.5970e-01, -3.9222e-02,  3.1496e-01,
          7.7765e-01,  3.2088e-03, -9.5037e-01,  1.6842e+00, -2.7472e-01,
          8.9495e-01, -6.6780e-01, -2.1917e+00, -8.9231e-01, -1.2503e-01,
         -7.6916e-01,  9.2977e-02, -1.0068e+00,  5.6095e-01, -4.3650e-01,
         -4.2963e-01,  1.1767e+00,  1.5873e-01,  8.1270e-01,  2.4282e-01,
          6.1882e-01,  1.9297e+00,  2.7768e-03,  1.3663e-01, -2.0949e+00,
          1.8813e+00,  1.7197e+00, -7.9407e-02,  2.5143e+00, -2.0963e+00,
          1.5809e+00,  2.2331e-01, -7.8078e-01,  1.3170e+00,  1.2812e-01,
         -1.8651e+00,  1.4497e+00, -1.2340e+00,  1.7757e-01,  9.9390e-01,
         -3.9311e-01, -1.6382e-03,  2.3383e-01,  4.5272e-01,  3.5482e-01,
         -3.3604e-01, -9.3516e-01, -3.1347e-01,  1.3623e+00, -7.4361e-02,
          7.4045e-01,  8.0236e-01, -3.2368e-01,  6.3069e-01, -1.3896e+00,
         -5.8012e-02,  7.2827e-01,  4.7116e-01,  5.6173e-01, -6.7654e-01,
          5.3626e-01,  9.4554e-01, -3.9603e-02, -1.4229e+00, -5.6620e-01,
          4.4772e-01,  2.7705e-01, -5.4747e-01,  9.2418e-01,  6.8657e-01,
         -6.2135e-02,  1.4296e-01,  3.5313e-01,  1.3227e+00, -8.6707e-01,
          9.8802e-01, -1.8308e+00, -9.7145e-01]])
64: 四步  词向量: tensor([[-1.1519e-01, -9.8370e-01,  8.9683e-01,  7.8583e-02,  6.8171e-01,
          1.5929e+00,  1.2414e+00,  4.4744e-02, -8.8165e-01, -3.1066e-01,
         -3.2233e-02,  3.3470e-01, -1.4127e-01, -3.6761e-03,  1.9378e+00,
         -2.0881e+00, -2.3337e+00, -1.6996e+00,  4.7872e-01,  4.3735e-01,
         -1.9272e+00,  4.9519e-02, -3.8391e-01,  1.1140e+00, -1.0786e+00,
          7.2027e-01, -1.1500e+00,  7.2772e-02,  1.8115e+00, -3.8328e-01,
         -8.6005e-01, -1.2892e+00,  7.5508e-01,  1.4564e-02,  2.1858e+00,
         -8.2394e-01, -2.5774e-01, -2.0778e+00, -6.1939e-01,  2.4040e+00,
         -7.9077e-01,  1.9725e+00, -3.6691e-01,  1.9984e-01,  5.5778e-01,
          1.1229e+00, -8.2752e-01,  1.0133e+00, -1.0626e+00,  1.3553e+00,
          9.8108e-01, -2.1485e-01, -6.4929e-01,  1.1640e+00,  7.6984e-01,
         -3.5187e-01, -1.6375e+00,  5.7573e-01,  5.0084e-02, -4.0885e-01,
         -2.6644e-02,  7.2604e-01, -1.3315e-01, -3.9336e-01,  2.3292e+00,
         -1.9080e+00,  1.5909e-01,  9.0571e-02,  1.3194e-04, -1.0185e+00,
          1.9428e-01, -1.7433e+00,  9.8780e-01,  8.2421e-02,  1.1351e+00,
         -1.3256e+00,  1.2815e+00, -1.3856e+00,  4.4290e-01, -6.5222e-01,
         -8.4154e-01,  1.9129e+00,  7.2862e-01,  6.5466e-01, -3.5003e-01,
          4.3143e-01, -9.8964e-01, -5.9240e-02,  6.0528e-01, -1.0780e+00,
          6.0879e-01,  7.0929e-01, -8.5609e-01,  2.2993e+00, -3.1809e-01,
         -1.4632e+00,  1.0808e+00,  9.9197e-01,  1.3919e+00,  4.9169e-01,
         -7.9783e-01, -4.6758e-01, -1.3620e-01,  1.0581e+00,  7.7175e-01,
         -7.6914e-01,  1.5600e+00,  1.8618e-01,  2.4299e+00,  1.4844e+00,
          2.1944e-01,  2.0768e+00,  6.5039e-01, -1.4695e-01, -1.1825e+00,
          2.3904e-01,  1.3650e-01, -1.4382e-01,  6.6381e-01, -1.4008e-01,
         -1.8280e+00,  1.6798e+00, -2.8428e-01,  1.3919e-01, -1.0410e+00,
         -3.9361e-01,  4.9195e-01,  8.6388e-01]])
65: 望   词向量: tensor([[ 0.1241,  0.3408,  0.3753,  0.2032, -0.2694,  0.3849,  0.1945,  2.5496,
         -0.2753,  1.3256, -0.8730,  0.3806,  1.0433, -0.1123, -0.9665, -0.9737,
         -1.5741, -0.9025,  0.6558,  0.7908,  0.2945,  1.1923, -0.7982,  1.5092,
         -0.5291, -0.6104,  0.2368, -0.9181,  0.7606, -0.5059,  0.0167,  2.3759,
          0.5298, -0.4443, -0.0848,  0.6960,  0.6826,  1.1171,  1.3161, -0.9244,
          0.1064,  1.1438, -1.3754, -0.3363, -0.6080,  1.0188, -0.6544,  0.9740,
         -0.4169,  0.5819,  1.0222, -1.3296,  0.6507,  0.7518, -0.9745, -1.5318,
          1.8925,  1.1480, -0.6524, -1.0280,  0.6995,  2.5830, -1.0279,  0.0774,
          0.2262, -0.0683,  2.0969,  0.5485,  0.9846,  0.3675,  0.6454,  0.1687,
          0.9284,  0.2790,  1.5492, -0.5730,  0.5825, -2.0112, -0.6177, -0.4560,
         -0.8300, -0.6018, -0.3029,  0.4510,  0.0798,  0.1019,  0.7190,  1.0135,
         -1.3040, -1.4357, -0.3265,  0.9620, -0.2163,  1.9211,  0.6877, -0.4949,
         -0.4345, -1.4830,  0.2423,  0.7857, -1.5926,  0.6691, -1.2324,  0.4993,
         -1.0496,  0.3796,  0.7865, -1.4122,  0.5166,  0.1025, -0.0085, -1.4805,
          1.0596, -0.8605, -1.0924, -0.4712, -0.2731, -2.2384, -0.0569, -0.6090,
          0.8119,  0.4555, -1.2355,  0.4860,  1.3225,  0.0208, -0.9553, -0.4149]])
66: 著天  词向量: tensor([[-0.9880,  0.0335,  1.3868, -0.8592, -0.6532, -1.1912, -0.1666, -1.6974,
          0.4223,  0.7032, -0.8819,  1.3296, -0.2070, -0.3874,  0.4051, -1.1049,
         -0.4800,  2.1483, -0.3965,  1.6693,  0.4499,  0.4128, -0.8221, -0.9146,
          0.5112, -0.2271,  0.8036, -0.8404,  0.4012, -0.2307,  0.7848, -1.3319,
          0.3837,  0.4600, -1.6393,  2.0505,  0.1815,  0.5192,  0.6952, -0.8248,
          0.4817, -1.3933, -0.9988, -0.2749,  0.2796, -1.4801,  1.0917, -1.7538,
         -0.4039, -1.0303,  0.9663,  1.2007,  1.0668, -0.8318, -2.5792,  1.0778,
          0.0976,  1.1202, -2.2210,  2.2378, -0.3914, -0.2341, -0.1081, -0.7162,
         -2.4974, -0.4599, -1.9009, -0.4083, -1.3762,  0.7436, -1.1261, -0.9869,
          0.2709,  0.7337,  1.0590,  0.3218,  0.7844,  0.3267,  1.7037,  1.0939,
          1.0560, -1.4140, -0.9326, -0.2127, -0.8218,  0.5245, -2.0479,  0.9608,
          0.0367, -1.5361, -0.4979, -1.0448, -0.5511, -0.0768,  0.6718, -1.8612,
         -0.1531,  1.7146, -0.0993, -1.5642,  0.8094, -1.4131, -0.2840, -0.5167,
          0.8219, -0.3373,  0.3086,  0.1353,  0.3373, -0.3680,  0.6317, -0.1202,
         -0.4661, -0.4880, -0.5316, -0.5198, -0.5909, -0.6734,  2.1747,  1.5025,
          0.0948,  0.7073, -0.1861,  1.2045, -1.4991,  0.0775,  2.3362, -1.1228]])
1: 
    词向量: tensor([[ 1.4771,  0.8061, -0.4299, -0.5632, -1.3281, -0.5809, -0.4281,  0.5693,
          0.6510, -0.1457, -0.2895, -1.2239, -0.8608, -1.1156,  1.4625,  0.9993,
          2.6551, -0.2841, -0.1222, -0.1759,  0.2747,  0.8773, -1.2195,  0.0723,
         -1.1253, -0.3896, -0.5094, -0.3521,  0.9901,  1.1108,  1.1191, -1.1345,
         -0.5516, -1.0788,  0.2044,  0.1993,  0.2574, -0.3992,  0.0040,  0.1144,
         -0.7567,  1.0407, -0.4901, -0.9804,  0.4055,  0.4972, -0.4097, -0.2506,
         -0.0374, -0.2787,  0.5761, -0.0540, -0.8492, -0.7583,  1.0121, -0.6011,
         -1.4103,  0.6407,  0.3240,  0.5556, -1.6938,  0.2747,  0.7353, -2.0933,
         -1.7379, -0.5252,  1.3509, -0.2661, -0.3593, -0.2447, -1.2453,  0.2860,
         -1.1808,  1.6014, -1.1948,  1.3895,  0.4737, -1.4571,  1.1382, -0.8261,
          0.5641, -2.5230,  0.2975,  1.0076, -2.1213,  0.0967,  0.6917,  1.7999,
          0.4339,  1.3127,  1.9793,  1.2312, -0.2442,  2.5434,  0.1964,  0.1350,
         -1.6063,  0.6460,  0.2100,  0.4153, -0.0708, -0.2820, -0.3491,  0.3494,
         -1.0825,  1.4995,  1.1523,  0.9549,  0.7601,  0.5949,  1.0576,  0.5871,
         -1.3045, -0.5725,  0.5301,  0.5057,  0.8488,  0.5929,  1.0189,  0.0787,
          0.9573, -0.7332,  0.9140, -0.4795,  0.2905,  0.9838,  0.3004, -0.2756]])