机器学习基础（完结篇）—初识推荐系统与计算机视觉

2 协同过滤代码实战

读取数据，分析数据
文件当中包含的数据包括：Y：每个用户对每一步电影的评分（每一列表示每一个用户对所有电影的评分情况）；R：每个用户是否对某一步电影进行了评分（是=1，否=0）

data2 = loadmat('ex8_movies.mat')
Y = data2['Y']
R = data2['R']
Y.shape,R.shape

结果如下:
在这里插入图片描述

根据公式编写代价函数

def cost(params,Y,R,features):
    """计算代价函数
    Params:
        params:存放X与Theta数据的narray
        Y:电影数量*用户数量的矩阵（包含了每一位用户对所有电影的平分情况）
        R:电影数量*用户数量的矩阵（用1表示第i个用户对第j部电影进行了评分）
        features:特征数量
    return:
        J:代价函数"""
    Y= np.mat(Y)
    R = np.mat(R)
    num_movies,num_users = Y.shape
    
    X = np.reshape(params[:num_movies*features],(num_movies,features)) #(1682,10)
    Theta = np.reshape(params[num_movies*features:],(num_users,features)) #(943,10)
    J = 0
    error = np.multiply(X@Theta.T - Y,R) #(1628,943),乘R的原因在于计算评价过的电影的误差
    square_error = np.power(error,2)
    J = (1/2) * np.sum(square_error)
    
    return J

if __name__ == '__main__':
    movies = 5
    users = 4
    features = 5

    X_ = X[:movies,:features]
    Theta_ = Theta[:users,:features]
    Y_ = Y[:movies,:users]
    R_ = R[:movies,:users]
    params_ = np.concatenate((np.ravel(X_),np.ravel(Theta_)))
    J = cost(params_,Y_,R_,features)
    print(J)

结果如下：
在这里插入图片描述

编写代替度函数的代价函数

def cost(params,Y,R,features):
    """计算代价函数
    Params:
        params:存放X与Theta数据的narray
        Y:电影数量*用户数量的矩阵（包含了每一位用户对所有电影的平分情况）
        R:电影数量*用户数量的矩阵（用1表示第i个用户对第j部电影进行了评分）
        features:特征数量
    return:
        J:代价函数
        grad:包含X与Theta梯度函数的narray"""
    Y= np.mat(Y)
    R = np.mat(R)
    num_movies,num_users = Y.shape
    
    X = np.reshape(params[:num_movies*features],(num_movies,features)) #(1682,10)
    Theta = np.reshape(params[num_movies*features:],(num_users,features)) #(943,10)
    J = 0
    X_grad = np.zeros((num_movies,features))
    Theta_grad = np.zeros((num_users,features))
    error = np.multiply(X@Theta.T - Y,R) #(1628,943),乘R的原因在于计算评价过的电影的误差
    square_error = np.power(error,2)
    J = (1/2) * np.sum(square_error)
    
    X_grad = error@Theta #(1682,10)
    Theta_grad = error.T@X #(943,10)
    grad = np.concatenate((np.ravel(X_grad),np.ravel(Theta_grad)))
    return J,grad

编写带正则化的梯度函数

def reg_cost(params,Y,R,features,learning_rate):
    """计算代价函数
    Params:
        params:存放X与Theta数据的narray
        Y:电影数量*用户数量的矩阵（包含了每一位用户对所有电影的平分情况）
        R:电影数量*用户数量的矩阵（用1表示第i个用户对第j部电影进行了评分）
        features:特征数量
    return:
        J:代价函数"""
    Y= np.mat(Y)
    R = np.mat(R)
    num_movies,num_users = Y.shape
    
    X = np.reshape(params[:num_movies*features],(num_movies,features)) #(1682,10)
    Theta = np.reshape(params[num_movies*features:],(num_users,features)) #(943,10)
    J = 0
    X_grad = np.zeros((num_movies,features))
    Theta_grad = np.zeros((num_users,features))
    error = np.multiply(X@Theta.T - Y,R) #(1628,943),乘R的原因在于计算评价过的电影的误差
    square_error = np.power(error,2)
    J = (1/2) * np.sum(square_error)
    J = J + (learning_rate/2)*np.sum(np.power(Theta,2))
    J = J + (learning_rate/2)*np.sum(np.power(X,2))
    
    
    
    X_grad = error@Theta  + (learning_rate*X)#(1682,10)
    Theta_grad = error.T@X + (learning_rate*Theta)#(943,10)
    grad = np.concatenate((np.ravel(X_grad),np.ravel(Theta_grad)))
    return J,grad

来给自己推荐电影，这里运用练习中给出的数据，首先读取文件，存储到字典当中

with open('movie_ids.txt',encoding= 'gbk') as f:
    movie_idx={
    
    }
    for each_movie in f:
        each_movie = each_movie.strip()
        tokens = each_movie.split(' ',1)
        movie_idx[int(tokens[0])-1] = tokens[1]
ratings = np.zeros((1682, 1)) #添加自己的一列

ratings[0] = 4
ratings[6] = 3
ratings[11] = 5
ratings[53] = 4
ratings[63] = 5
ratings[65] = 3
ratings[68] = 5
ratings[97] = 2
ratings[182] = 4
ratings[225] = 5
ratings[354] = 5
Y_add = np.append(Y,ratings,axis=1)
R_add = np.append(R,ratings!=0,axis=1)
movie_idx[0]

在这里插入图片描述

进行均值归一化
步骤：计算每一部电影的评价分->用原来的电影评分-平均分->

movies_num =Y.shape[0]
user_num =Y.shape[1]
features =10
learning_rate = 10.
X_test = np.random.random(size=(movies_num*features)) #随机初始化
Theta_test = np.random.random(size=(user_num*features))
params_test = np.concatenate((X_test.ravel(),Theta_test.ravel()))
# 均值归一化
Ymean  = np.zeros((Y.shape[0],1)) #初始化所有电影的评价得分
Ynorm = np.zeros((Y.shape[0],user_num))
m = Y.shape[0]
for i in range(m):
    index = np.where(R[i,:]==1)[0]
    Ymean[i] = Y[i,index].mean()
    Ynorm[i,index] = Y[i,index]-Ymean[i]
    
Ynorm.mean()

在这里插入图片描述

训练模型

from scipy.optimize import minimize
fmin = minimize(fun=reg_cost
                ,x0=params_test
                ,args=(Ynorm,R_add,features,learning_rate)
               ,method = 'CG', jac = True,options={
    
    'maxiter':100})

fmin

协同优化
在这里插入图片描述

推荐电影

X = np.reshape(fmin.x[:movies_num*features],(movies_num,features))
Theta = np.reshape(fmin.x[movies_num*features:],(user_num,features))
predictions = X@Theta.T #所有的预测值
my_pred = predictions[:,-1].reshape(Ymean.shape[0],1) + Ymean #预测我自己的电影偏好
#获取喜欢电影前十部的索引
inx = np.argsort(my_pred,axis=0)[::-1]
count = 1
for i in range(10):
    movie_name = movie_idx[int(inx[i,:])]
    print('Top {} movies U might like:{}'.format(count,movie_name))
    count+=1