通过Netflix案例研究和NVIDIA深度学习技术深入了解推荐算法

Python
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def user_based_cf(ratings_matrix, user_id, k=5):
 similarities = cosine_similarity(ratings_matrix)
 user_similarities = similarities[user_id]
 similar_users = np.argsort(user_similarities)[::-1][1:k+1]

 recommendations = np.zeros(ratings_matrix.shape[1])
 for similar_user in similar_users:
 recommendations += ratings_matrix[similar_user]

return recommendations / k

Python
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def item_based_cf(ratings_matrix, item_id, k=5):
    similarities = cosine_similarity(ratings_matrix.T)
    item_similarities = similarities[item_id]
    similar_items = np.argsort(item_similarities)[::-1][1:k+1]
    
    recommendations = np.zeros(ratings_matrix.shape[0])
    for similar_item in similar_items:
        recommendations += ratings_matrix[:, similar_item]
    
return recommendations / k

Python
import numpy as np

def matrix_factorization(R, P, Q, K, steps=5000, alpha=0.0002, beta=0.02):
    Q = Q.T
    for step in range(steps):
        for i in range(len(R)):
            for j in range(len(R[i])):
                if R[i][j] > 0:
                    eij = R[i][j] - np.dot(P[i,:], Q[:,j])
                    for k in range(K):
                        P[i][k] += alpha * (2 * eij * Q[k][j] - beta * P[i][k])
                        Q[k][j] += alpha * (2 * eij * P[i][k] - beta * Q[k][j])
        
        e = 0
        for i in range(len(R)):
            for j in range(len(R[i])):
                if R[i][j] > 0:
                    e += pow(R[i][j] - np.dot(P[i,:], Q[:,j]), 2)
                    for k in range(K):
                        e += (beta/2) * (pow(P[i][k], 2) + pow(Q[k][j], 2))
        if e < 0.001:
            break
return P, Q.T

Python
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

def content_based_filtering(item_descriptions, user_profile, k=5):
    vectorizer = TfidfVectorizer()
    item_vectors = vectorizer.fit_transform(item_descriptions)
    user_vector = vectorizer.transform([user_profile])
    
    similarities = cosine_similarity(user_vector, item_vectors)
    top_items = np.argsort(similarities[0])[::-1][:k]
    
return top_items

Python
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def hybrid_recommender(ratings_matrix, content_matrix, user_id, alpha=0.5, k=5):
    cf_similarities = cosine_similarity(ratings_matrix)
    content_similarities = cosine_similarity(content_matrix)
    
    hybrid_similarities = alpha * cf_similarities + (1 - alpha) * content_similarities
    user_similarities = hybrid_similarities[user_id]
    
    similar_users = np.argsort(user_similarities)[::-1][1:k+1]
    
    recommendations = np.zeros(ratings_matrix.shape[1])
    for similar_user in similar_users:
        recommendations += ratings_matrix[similar_user]
    
return recommendations / k

Python
import numpy as np
from scipy.sparse.linalg import svds

def svd_recommender(ratings_matrix, k=5):
    U, s, Vt = svds(ratings_matrix, k=k)
    
    sigma = np.diag(s)
    predicted_ratings = np.dot(np.dot(U, sigma), Vt)
    
return predicted_ratings

Python
import numpy as np
import tensorly as tl
from tensorly.decomposition import parafac

def tensor_factorization_recommender(tensor, rank=10):
    factors = parafac(tensor, rank=rank)
    reconstructed_tensor = tl.kruskal_to_tensor(factors)
return reconstructed_tensor

Python
import tensorflow as tf
from tensorflow.keras.layers import Input, Embedding, Flatten, Dense, Concatenate
from tensorflow.keras.models import Model

def neural_collaborative_filtering(num_users, num_items, embedding_size=100):
    user_input = Input(shape=(1,), dtype='int32', name='user_input')
    item_input = Input(shape=(1,), dtype='int32', name='item_input')

    user_embedding = Embedding(num_users, embedding_size, name='user_embedding')(user_input)
    item_embedding = Embedding(num_items, embedding_size, name='item_embedding')(item_input)

    user_vecs = Flatten()(user_embedding)
    item_vecs = Flatten()(item_embedding)

    concat = Concatenate()([user_vecs, item_vecs])
    dense1 = Dense(128, activation='relu')(concat)
    dense2 = Dense(64, activation='relu')(dense1)
    output = Dense(1, activation='sigmoid')(dense2)

    model = Model(inputs=[user_input, item_input], outputs=output)
    model.compile(optimizer='adam', loss='binary_crossentropy')

Python
import nvtabular as nvt
import glob
 
cont_names = ["I"+str(x) for x in range(1, 14)] # specify continuous feature names
cat_names = ["C"+str(x) for x in range(1, 27)] # specify categorical feature names
label_names = ["label"] # specify target feature
columns = label_names + cat_names + cont_names # all feature names
 
# initialize Workflow
proc = nvt.Worfklow(cat_names=cat_names, cont_names=cont_names, label_name=label_names)
 
# create datsets from input files
train_files = glob.glob("./dataset/train/*.parquet")
valid_files = glob.glob("./dataset/valid/*.parquet")
 
train_dataset = nvt.dataset(train_files, gpu_memory_frac=0.1)
valid_dataset = nvt.dataset(valid_files, gpu_memory_frac=0.1)
 
# add feature engineering and preprocessing ops to Workflow
proc.add_cont_feature([nvt.ops.ZeroFill(), nvt.ops.LogOp()])
proc.add_cont_preprocess(nvt.ops.Normalize())
proc.add_cat_preprocess(nvt.ops.Categorify(use_frequency=True, freq_threshold=15))
 
# compute statistics, transform data, export to disk
proc.apply(train_dataset, shuffle=True, output_path="./processed_data/train", num_out_files=len(train_files))
proc.apply(valid_dataset, shuffle=False, output_path="./processed_data/valid", num_out_files=len(valid_files))