test_method.py

一、处理流程

1. def compute_embedding(net, road_network, test_traj, test_time, test_batch):

　　if len(test_traj) <= test_batch:
　　　　embedding = net(road_network, test_traj, test_time)
　　　　return embedding
　　else:
　　　　i = 0
　　　　all_embedding = []
　　　　while i < len(test_traj):
　　　　　　embedding = net(road_network, test_traj[i:i+test_batch], test_time[i:i+test_batch])
　　　　　　all_embedding.append(embedding)
　　　　　　i += test_batch
　　all_embedding = torch.cat(all_embedding,0)
　　return all_embedding

 

2. def test_model(embedding_set, isvali=False):

embedding_dis_matrix = []
for t in embedding_set:  # 计算嵌入向量集合中每个向量与其他向量之间的欧几里德距离，并将距离组成的矩阵存储在 embedding_dis_matrix
    emb = np.repeat([t], repeats=len(embedding_set), axis=0)
    matrix = np.linalg.norm(emb-embedding_set, ord=2, axis=1)
    embedding_dis_matrix.append(matrix.tolist())

l_recall_10 = 0
l_recall_50 = 0
l_recall_10_50 = 0

f_num = 0

# 比较输入向量矩阵和嵌入向量矩阵中的距离，并计算召回率
for i in range(len(input_dis_matrix)):
    input_r = np.array(input_dis_matrix[i])
    one_index = []
    for idx, value in enumerate(input_r):
        if value != -1:
            one_index.append(idx)
    input_r = input_r[one_index]
    input_r = input_r[:5000]

    # np.argsort(input_r) 对数组 input_r 中的元素进行排序，并返回排序后的元素索引数组
    # 然后，取索引数组中从第一个元素开始到第 50 个元素（不包括第 51 个元素）的部分，并将其赋值给 input_r50
    input_r50 = np.argsort(input_r)[1:51]
    # 接着，从 input_r50 中取前 10 个元素，并将其赋值给 input_r10
    input_r10 = input_r50[:10]

    embed_r = np.array(embedding_dis_matrix[i])
    embed_r = embed_r[one_index]
    embed_r = embed_r[:5000]

    embed_r50 = np.argsort(embed_r)[1:51]
    embed_r10 = embed_r50[:10]

    if len(one_index)>=51:
        f_num += 1
        l_recall_10 += len(list(set(input_r10).intersection(set(embed_r10))))
        l_recall_50 += len(list(set(input_r50).intersection(set(embed_r50))))
        l_recall_10_50 += len(list(set(input_r50).intersection(set(embed_r10))))
# 用于评估模型的推荐结果与真实结果之间的匹配程度，即模型预测的结果中有多少与真实结果相符，以此来衡量模型的召回率。
recall_10 = float(l_recall_10) / (10 * f_num)
recall_50 = float(l_recall_50) / (50 * f_num)
recall_10_50 = float(l_recall_10_50) / (10 * f_num)

return recall_10, recall_50, recall_10_50