图表示学习与 node2vec

pip install networkx

import os
from collections import defaultdict
import math
import networkx as nx
import random
from tqdm import tqdm
from zipfile import ZipFile
from urllib.request import urlretrieve
import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import matplotlib.pyplot as plt

urlretrieve(
    "http://files.grouplens.org/datasets/movielens/ml-latest-small.zip", "movielens.zip"
)
ZipFile("movielens.zip", "r").extractall()

# 将电影加载到 DataFrame 中。
movies = pd.read_csv("ml-latest-small/movies.csv")
# 创建一个 `movieId` 字符串。
movies["movieId"] = movies["movieId"].apply(lambda x: f"movie_{x}")

# 将评分加载到 DataFrame 中。
ratings = pd.read_csv("ml-latest-small/ratings.csv")
# 将 `ratings` 转换为浮点数
ratings["rating"] = ratings["rating"].apply(lambda x: float(x))
# 创建 `movie_id` 字符串。
ratings["movieId"] = ratings["movieId"].apply(lambda x: f"movie_{x}")

print("Movies data shape:", movies.shape)
print("Ratings data shape:", ratings.shape)

ratings.head()

movies.head()

def get_movie_title_by_id(movieId):
    return list(movies[movies.movieId == movieId].title)[0]


def get_movie_id_by_title(title):
    return list(movies[movies.title == title].movieId)[0]

min_rating = 5
pair_frequency = defaultdict(int)
item_frequency = defaultdict(int)

# 过滤评分大于或等于 min_rating 的实例。
rated_movies = ratings[ratings.rating >= min_rating]
# 按用户分组实例。
movies_grouped_by_users = list(rated_movies.groupby("userId"))
for group in tqdm(
    movies_grouped_by_users,
    position=0,
    leave=True,
    desc="计算电影评分频率",
):
    # 获取用户评分的电影列表。
    current_movies = list(group[1]["movieId"])

    for i in range(len(current_movies)):
        item_frequency[current_movies[i]] += 1
        for j in range(i + 1, len(current_movies)):
            x = min(current_movies[i], current_movies[j])
            y = max(current_movies[i], current_movies[j])
            pair_frequency[(x, y)] += 1

min_weight = 10
D = math.log(sum(item_frequency.values()))

# 创建电影无向图。
movies_graph = nx.Graph()
# 添加电影之间的加权边。
# 这会自动将电影节点添加到图中。
for pair in tqdm(
    pair_frequency, position=0, leave=True, desc="创建电影图"
):
    x, y = pair
    xy_frequency = pair_frequency[pair]
    x_frequency = item_frequency[x]
    y_frequency = item_frequency[y]
    pmi = math.log(xy_frequency) - math.log(x_frequency) - math.log(y_frequency) + D
    weight = pmi * xy_frequency
    # 仅包含权重 >= min_weight 的边。
    if weight >= min_weight:
        movies_graph.add_edge(x, y, weight=weight)

print("图中节点的总数:", movies_graph.number_of_nodes())
print("图中边的总数:", movies_graph.number_of_edges())

degrees = []
for node in movies_graph.nodes:
    degrees.append(movies_graph.degree[node])

print("平均节点度:", round(sum(degrees) / len(degrees), 2))

vocabulary = ["NA"] + list(movies_graph.nodes)
vocabulary_lookup = {token: idx for idx, token in enumerate(vocabulary)}

def next_step(graph, previous, current, p, q):
    neighbors = list(graph.neighbors(current))

    weights = []
    # 根据 p 和 q 调整与邻居的边的权重。
    for neighbor in neighbors:
        if neighbor == previous:
            # 控制返回前一个节点的概率。
            weights.append(graph[current][neighbor]["weight"] / p)
        elif graph.has_edge(neighbor, previous):
            # 访问本地节点的概率。
            weights.append(graph[current][neighbor]["weight"])
        else:
            # 控制向前移动的概率。
            weights.append(graph[current][neighbor]["weight"] / q)

    # 计算访问每个邻居的概率。
    weight_sum = sum(weights)
    probabilities = [weight / weight_sum for weight in weights]
    # 按概率选择一个邻居访问。
    next = np.random.choice(neighbors, size=1, p=probabilities)[0]
    return next


def random_walk(graph, num_walks, num_steps, p, q):
    walks = []
    nodes = list(graph.nodes())
    # 执行多次随机游走的迭代。
    for walk_iteration in range(num_walks):
        random.shuffle(nodes)

        for node in tqdm(
            nodes,
            position=0,
            leave=True,
            desc=f"随机游走迭代 {walk_iteration + 1} 的 {num_walks}",
        ):
            # 从图中随机节点开始游走。
            walk = [node]
            # 随机游走 num_steps。
            while len(walk) < num_steps:
                current = walk[-1]
                previous = walk[-2] if len(walk) > 1 else None
                # 计算下一个要访问的节点。
                next = next_step(graph, previous, current, p, q)
                walk.append(next)
            # 用 token id 替换游走中的节点 id（电影 id）。
            walk = [vocabulary_lookup[token] for token in walk]
            # 将游走添加到生成的序列中。
            walks.append(walk)

    return walks

# 随机游走返回参数。
p = 1
# 随机游走内外参数。
q = 1
# 随机游走的迭代次数。
num_walks = 5
# 每次随机游走的步数。
num_steps = 10
walks = random_walk(movies_graph, num_walks, num_steps, p, q)

print("生成的游走数量:", len(walks))

def generate_examples(sequences, window_size, num_negative_samples, vocabulary_size):
    example_weights = defaultdict(int)
    # 遍历所有序列（游走）。
    for sequence in tqdm(
        sequences,
        position=0,
        leave=True,
        desc=f"生成正例和负例",
    ):
        # 为一个序列（游走）生成正例和负例的跳字对。
        pairs, labels = keras.preprocessing.sequence.skipgrams(
            sequence,
            vocabulary_size=vocabulary_size,
            window_size=window_size,
            negative_samples=num_negative_samples,
        )
        for idx in range(len(pairs)):
            pair = pairs[idx]
            label = labels[idx]
            target, context = min(pair[0], pair[1]), max(pair[0], pair[1])
            if target == context:
                continue
            entry = (target, context, label)
            example_weights[entry] += 1

    targets, contexts, labels, weights = [], [], [], []
    for entry in example_weights:
        weight = example_weights[entry]
        target, context, label = entry
        targets.append(target)
        contexts.append(context)
        labels.append(label)
        weights.append(weight)

    return np.array(targets), np.array(contexts), np.array(labels), np.array(weights)


num_negative_samples = 4
targets, contexts, labels, weights = generate_examples(
    sequences=walks,
    window_size=num_steps,
    num_negative_samples=num_negative_samples,
    vocabulary_size=len(vocabulary),
)

print(f"Targets shape: {targets.shape}")
print(f"Contexts shape: {contexts.shape}")
print(f"Labels shape: {labels.shape}")
print(f"Weights shape: {weights.shape}")

batch_size = 1024


def create_dataset(targets, contexts, labels, weights, batch_size):
    inputs = {
        "target": targets,
        "context": contexts,
    }
    dataset = tf.data.Dataset.from_tensor_slices((inputs, labels, weights))
    dataset = dataset.shuffle(buffer_size=batch_size * 2)
    dataset = dataset.batch(batch_size, drop_remainder=True)
    dataset = dataset.prefetch(tf.data.AUTOTUNE)
    return dataset


dataset = create_dataset(
    targets=targets,
    contexts=contexts,
    labels=labels,
    weights=weights,
    batch_size=batch_size,
)

learning_rate = 0.001
embedding_dim = 50
num_epochs = 10

def create_model(vocabulary_size, embedding_dim):

    inputs = {
        "target": layers.Input(name="target", shape=(), dtype="int32"),
        "context": layers.Input(name="context", shape=(), dtype="int32"),
    }
    # 初始化项目嵌入。
    embed_item = layers.Embedding(
        input_dim=vocabulary_size,
        output_dim=embedding_dim,
        embeddings_initializer="he_normal",
        embeddings_regularizer=keras.regularizers.l2(1e-6),
        name="item_embeddings",
    )
    # 查找目标的嵌入。
    target_embeddings = embed_item(inputs["target"])
    # 查找上下文的嵌入。
    context_embeddings = embed_item(inputs["context"])
    # 计算目标和上下文嵌入之间的点积相似度。
    logits = layers.Dot(axes=1, normalize=False, name="dot_similarity")(
        [target_embeddings, context_embeddings]
    )
    # 创建模型。
    model = keras.Model(inputs=inputs, outputs=logits)
    return model

model = create_model(len(vocabulary), embedding_dim)
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate),
    loss=keras.losses.BinaryCrossentropy(from_logits=True),
)

keras.utils.plot_model(
    model,
    show_shapes=True,
    show_dtype=True,
    show_layer_names=True,
)

history = model.fit(dataset, epochs=num_epochs)

plt.plot(history.history["loss"])
plt.ylabel("loss")
plt.xlabel("epoch")
plt.show()

movie_embeddings = model.get_layer("item_embeddings").get_weights()[0]
print("Embeddings shape:", movie_embeddings.shape)

query_movies = [
    "Matrix, The (1999)",
    "Star Wars: Episode IV - A New Hope (1977)",
    "Lion King, The (1994)",
    "Terminator 2: Judgment Day (1991)",
    "Godfather, The (1972)",
]

query_embeddings = []

for movie_title in query_movies:
    movieId = get_movie_id_by_title(movie_title)
    token_id = vocabulary_lookup[movieId]
    movie_embedding = movie_embeddings[token_id]
    query_embeddings.append(movie_embedding)

query_embeddings = np.array(query_embeddings)

similarities = tf.linalg.matmul(
    tf.math.l2_normalize(query_embeddings),
    tf.math.l2_normalize(movie_embeddings),
    transpose_b=True,
)

_, indices = tf.math.top_k(similarities, k=5)
indices = indices.numpy().tolist()

for idx, title in enumerate(query_movies):
    print(title)
    print("".rjust(len(title), "-"))
    similar_tokens = indices[idx]
    for token in similar_tokens:
        similar_movieId = vocabulary[token]
        similar_title = get_movie_title_by_id(similar_movieId)
        print(f"- {similar_title}")
    print()

import io

out_v = io.open("embeddings.tsv", "w", encoding="utf-8")
out_m = io.open("metadata.tsv", "w", encoding="utf-8")

for idx, movie_id in enumerate(vocabulary[1:]):
    movie_title = list(movies[movies.movieId == movie_id].title)[0]
    vector = movie_embeddings[idx]
    out_v.write("\t".join([str(x) for x in vector]) + "\n")
    out_m.write(movie_title + "\n")

out_v.close()
out_m.close()