import numpy as np
 
A = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
arr1 = np.array(A)
print("A=", A)
print("arr1=\n", arr1)
B = ((1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12))
arr2 = np.array(B)
print("B=", B)
print("arr2=\n", arr2)
 
print("type(A)=", type(A))
print("type(B)=", type(B))
print("type(arr1)=", type(arr1))
print("arr1.shape=", arr1.shape)

import numpy as np
 
arr1 = np.random.random((2, 3))
print("arr1=\n", arr1)
arr2 = np.random.randint(3, 30, size=[2, 3])  # 3-30(不包括 30)
print("arr2=\n", arr2)

import numpy as np
 
A = [1, 2, 3, 4, 5, 6]
B = np.array(A)
C1 = B.reshape(2, 3)
C2 = B.reshape(3, 2)
print("B=", B)
print("C1=\n", C1)
print("C2=\n", C2)

C1[0]  # 第 0 行

C1[0:2]  #  0-2(不含 2)行

C2[[0, 2]]  # 第 0 行和第 2 行

C2[:, 1]  # 第 1 列

C2[:, 0:2]  # 0-2(不含 2)列

C1[:, [0, 2]]  # 第 0 列和第 2 列

C2[2, 1]  # 第 2 行第 1 列

C2[2][1]  # 第 2 行第 1 列

import numpy as np
 
A = [[1, 2, 3, 4, 5]]
B = [[1], [2], [3], [4], [5]]
C = np.array(A)
D = np.array(B)
print("C=\n", C)
print("D=\n", D)
print("C.shape", np.shape(C))
print("D.shape", np.shape(D))

np.zeros(10)

np.zeros((2, 4))

np.array([np.zeros(10)])

np.eye(3)

np.identity(3)

arr1 = np.diag([1, 2, 3])
arr1

np.diag(arr1)

A = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
np.triu(A, 0)

np.tril(A, 0)

A = np.array([[1, 2, 3], [4, 5, 6]])
B = np.array([1, 2, 3, 4, 5, 6]).reshape(2, 3)
np.allclose(A, B)

A = np.array([[1, 2], [1, 0]])
B = np.diag([2, 2])
A.dot(B)  # 矩阵乘法 AB

A * B  # np.array 类型, * 表示对应元素相乘

np.multiply(A, B)

A = np.mat([[1, 2], [1, 0]])
B = np.mat(np.diag([2, 2]))
A * B  # np.mat 类型, * 表示矩阵乘法

A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
A_array = np.array(A)
A_matrix = np.mat(A)
A_array.dot(A_array).dot(A_array)

A_array ** 3

A_matrix ** 3

import numpy as np
 
arr1 = np.random.randint(1, 16, size=[3, 3])
arr2 = np.triu(arr1)
arr2 += arr2.T - np.diag(np.diag(arr2))
 
print("arr1=\n", arr1)
print("arr2=\n", arr2)
print(np.allclose(arr2, arr2.T))

import numpy as np
 
A = [[1, 2], [2, 5]]
C1 = np.array(A)
C2 = np.mat(A)
C1_inverse = np.linalg.inv(C1)  # array 类型不能使用 C1.I
C2_inverse = C2.I
print("C1_inverse=\n", C1_inverse)
print("C2_inverse=\n", C2_inverse)
print("C1.dot(C1_inverse)=\n", C1.dot(C1_inverse))

C2 ** (-1)

try:
    np.mat([[0, 0], [0, 1]]) ** (-1)
excerpt excerption as e:
    print(e)

np.linalg.det(np.diag([1, 2, 3, 4]))  # np.linalg 线性代数

np.linalg.matrix_rank(np.diag([1, 2, 3]))

np.linalg.matrix_rank(np.diag([1, 2, 0]))

A = [[1, 2, 3]]
B = [[4, 5, 6]]
C1 = np.array(A).reshape(3, 1)  # 转换成列向量
C2 = np.array(B).reshape(3, 1)
np.dot(C1.T, C2)

A = np.array([[0, 3, 4]])
np.linalg.norm(A)

import numpy as np
 
A = np.mat([[1, 2, 1], [2, -1, 3], [3, 1, 2]])
B = np.mat([7, 7, 18]).reshape(3, 1)
AB = np.hstack((A, B))
AB

X = A.I * B
X

A * X  # 验证

np.linalg.solve(A, B)

import sympy
from sympy.abc import x, y, z
 
eq = [x + 2 * y + z - 7, 
      2 * x - y + 3 * z - 7, 
      3 * x + y + 2 * z - 18]
sympy.solve(eq, [x, y, z])

import numpy as np
 
A = np.array([[1, 2, 1, -2],
             [2, 3, 0, -1],
             [1, -1, -5, 7]])
np.linalg.matrix_rank(A)

import sympy
from sympy.abc import x, y, z, w
 
eq = [x + 2 * y + z - 2 * w, 2 * x + 3 * y - w, x - y - 5 * z + 7 * w]
result = sympy.solve(eq, [x, y, z, w])
result

A = {z:1, w:2}
x = float(result[x].evalf(subs=A))
y = float(result[y].evalf(subs=A))
x, y

import pandas as pd
import numpy as np
 
dataset = pd.read_csv("iris.csv")
data = np.array(dataset)

import numpy as np
 
A = np.mat([[1, 1, 1],
            [1, 2, 4],
            [1, 3, 9]])
B = np.mat([2, 3, 5]).reshape(3, 1)
AB = np.hstack((A, B))
AB

A.I * B

np.linalg.solve(A, B)

import sympy
from sympy.abc import x, y, z
 
eq = [x + y + z - 2, x + 2 * y + 4 * z - 3, x + 3 * y + 9 * z - 5]
sympy.solve(eq, [x, y, z])

import numpy as np
 
A = np.random.randint(1, 20, size=[3, 4])
B = np.random.randint(1, 20, size=[4, 5])
A, B

A.dot(B)

np.linalg.matrix_rank(A)

np.linalg.matrix_rank(B)

import numpy as np
 
A = np.mat([[1, 2, 3],
            [2, 2, 1],
            [3, 4, 3]])
np.linalg.det(A)

A.I

np.zeros((4, 4))

np.identity(4)

np.diag([1, 2, 3, 4])

A = np.random.random(16).reshape(4, 4) * 20
A

np.triu(A)

np.triu(A).T + np.triu(A) - np.diag(np.diag(A))

np.tril(A).T + np.tril(A) - np.diag(np.diag(A))

import numpy as np
 
A = np.array([[4, 2], [1, 5]])
eig_val, eig_vex = np.linalg.eig(A)  # eig()函数分别求解特征值和特征向量矩阵

eig_val  # 特征值

eig_vex  # 特征向量矩阵(已标准化)

import numpy as np
 
# A = np.array([[1, 5, 7, 6, 1], [2, 1, 10, 4, 4], [3, 6, 7, 5, 2]])
A = np.array([[0, 1], [1, 1], [1, 0]])  # https://zhuanlan.zhihu.com/p/29846048
A

sigmal_val, U = np.linalg.eigh(A.dot(A.T))  # 计算特征值, 左奇异矩阵
sigmal_sort_id = np.argsort(sigmal_val)[::-1]  # 让特征值降序排列
sigmal_val = np.sort(sigmal_val)[::-1]  # 特征值对应的特征向量也对应排序
U = U[:, sigmal_sort_id]  # 左奇异矩阵按这个 id 排序
sigmal = np.diag(np.sqrt(sigmal_val))  # 计算奇异值矩阵(方阵)
sigmal_inv = np.linalg.inv(sigmal)  # 奇异值矩阵的逆矩阵
V_part_T = sigmal_inv.dot(U.T).dot(A)  # 右奇异矩阵
 
print("AAT=:\n", AAT)
print("左奇异矩阵: \n", U)
print("奇异值矩阵: \n", np.round(sigmal, 2))
print("右奇异矩阵的转置(部分):\n", np.round(V_part_T, 6))

np.round(U.dot(sigmal).dot(V_part_T), 2)

U, s, VT = np.linalg.svd(A)
Sigma = np.zeros(np.shape(A))  # 先创建一个零矩阵
Sigma[:len(s), :len(s)] = np.diag(s)  # 将该矩阵的对角元素替换为奇异值
print("左奇异矩阵: \n", U)
print("奇异值:\n", s)
print("奇异值矩阵: \n", Sigma)
print("右奇异矩阵的转置:\n", VT)

np.round(U.dot(Sigma).dot(VT), 2)

import numpy as np
 
A = np.array([[1, 5, 7, 6, 1], [2, 1, 10, 4, 4], [3, 6, 7, 5, 2]])
A

U, s, VT = np.linalg.svd(A)
Sigma = np.zeros(np.shape(A))  # 先创建一个零矩阵
Sigma[:len(s), :len(s)] = np.diag(s)  # 将该矩阵的对角元素替换为奇异值
 
for k in range(3, 0, -1):
    D = U[:, :k].dot(Sigma[:k, :k].dot(VT[:k, :]))
    print("k=", k, "压缩后的矩阵: \n", np.round(D, 1))

from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
 
 
def get_approx_SVD1(data, percent):
    """
    SVD 并还原压缩后的数据, 取整体奇异值的百分比
    :param data: 原始矩阵
    :param percent: 奇异值总和百分比
    """
    U, s, VT = np.linalg.svd(data)
    Sigma = np.zeros(np.shape(data))
    Sigma[:len(s), :len(s)] = np.diag(s)
    count = (int)(sum(s)) * percent  # 取整体奇异值的百分比
    k = -1  # k 是奇异值总和的百分比的个数
    curSum = 0  # 初始为第一个奇异值
    while curSum <= count:  # 当取的奇异值之和 <= 应取得奇异值之和 时:
        k += 1
        curSum += s[k]
    D = U[:, :k].dot(Sigma[:k, :k].dot(VT[:k, :]))  # 取 U 的前 k 列, Sigma 的前 k 阶方阵, VT 的前 k 行
    D[D < 0] = 0  # 钳制颜色范围
    D[D > 255] = 255
    # numpy.rint()将数组的元素四舍五入为最接近的整数
    return np.rint(D).astype("uint8")
 
 
def get_approx_SVD2(data, percent):
    """
    SVD 并还原压缩后的数据, 取奇异值之和的百分比
    :param data: 原始矩阵
    :param percent: 奇异值个数百分比
    """
    U, s, VT = np.linalg.svd(data)
    Sigma = np.zeros(np.shape(data))
    Sigma[:len(s), :len(s)] = np.diag(s)
    k = (int)(percent * len(s))  # 取最大的前 k 个奇异值
    D = U[:, :k].dot(Sigma[:k, :k].dot(VT[:k, :]))
    D[D < 0] = 0
    D[D > 255] = 255
    return np.rint(D).astype("uint8")
 
 
def rebuild_img(filename, p, get_approx_SVD, index):
    """
    导入图像, 进行 SVD 压缩, 并重构图像
    :param filename: 文件名
    :param p: 百分比
    :param get_approx_SVD: 调用的 SVD 筛选方法
    :param index: 显示图像的序号
    """
    img = Image.open(filename, 'r')
    a = np.array(img)
    R0 = a[:, :, 0]  # 红色
    G0 = a[:, :, 1]  # 绿色
    B0 = a[:, :, 2]  # 蓝色
    R = get_approx_SVD(R0, p)
    G = get_approx_SVD(G0, p)
    B = get_approx_SVD(B0, p)
    I = np.stack((R, G, B), 2)
 
    # 加载图像
    plt.subplot(2, 5, index)
    if get_approx_SVD == get_approx_SVD1:
        plt.title("SVD1 " + str((int)(p * 100)) + '%')
    else:
        plt.title("SVD2 " + str((int)(p * 100)) + '%')
    plt.imshow(I)
    plt.axis('off')
 
 
if __name__ == "__main__":
    filename = "lenna.bmp"
    plt.figure(figsize=(10, 5))
    index = 0
    for p in np.arange(0.2, 1.2, 0.2):
        index += 1
        rebuild_img(filename, p, get_approx_SVD1, index)
    for p in np.arange(0.2, 1.2, 0.2):
        index += 1
        rebuild_img(filename, p, get_approx_SVD2, index)
    plt.show()
 

import numpy as np
from numpy import linalg as la
import pandas as pd
import time

def loadExData():
    """
    行: 代表用户
    列: 代表电影
    值: 代表用户对电影的评分, 0 表示未评分
    :return: 将 csv 转换成的 np.array 数组
    """
    """
    pd.read_csv():
    sep：读取 csv 文件时指定的分隔符，默认为逗号。
    header：设置导入 DataFrame 的列名称(第一行)，默认为 "infer"
    """
    return np.array(pd.read_csv("评分.csv", sep=",", header=None))

"""
以下三种计算方式的参数 X 和 Y 都采用一维数组(向量), 返回的值越接近 1, 相关度越强
"""
 
 
def ecludSim(X, Y):
    """
    利用欧氏距离计算相似度, 并归一化
    """
    return 1.0 / (1.0 + la.norm(X - Y))
 
 
def pearsSim(X, Y):
    """
    利用皮尔逊相关系数计算相似度, 并归一化
    """
    if len(X < 3):
        return 1.0
    else:
        return 0.5 + 0.5 * np.corrcoef(X, Y, rowvar=1)[0][1]
    
    
def cosSim(X, Y):
    """
    利用余弦相似度计算相似度, 并归一化
    """
    return 0.5 + 0.5 * (float(X.dot(Y)) / (la.norm(X) * la.norm(Y)))

def SigmaPct(sigma, percentage):
    """
    按照前 k 个奇异值的平方和占总奇异值的平方和的百分比 percentage 确定 k 的值
    后续计算 SVD 时需要将 item 原始矩阵降维
    """
    sum_sigma = sum(sigma ** 2)
    sum_sigma1 = sum_sigma * percentage  # 求所有奇异值 sigma 的平方和的百分比
    sum_sigma2 = 0
    k = 0
    for i in sigma:
        sum_sigma2 += i * i
        k += 1
        if sum_sigma2 >= sum_sigma1:
            return k

def svd_item(data, percentage):
    """
    降维处理
    :return: 降维的物品数据
    """
    n = np.shape(data)[1]  # 物品种类数据
    U, s, VT = la.svd(data)  # 数据集进行奇异值分解，返回的 s 为对角线上的值
    k = SigmaPct(s, percentage)  # 确定了 k 的值,前 k 个已经包含了 percentage 的能力
    Sigma = np.eye(k) * s[:k]  # 构建对角矩阵
    # 将数据转换到 k 维空间(低维)，构建转换后的物品
    return data.T.dot(U[:, :k].dot(la.inv(Sigma)))  # 返回降维的物品数据

def svd_predict(data, user, simMeas, FormedItems, item):
    """
    基于 item 的相似性对用户未评过分的物品进行预测评分
    :param data: 数组矩阵
    :param user: 用户编号
    :param simMeas: 相似度算法
    :param FormedItems: 数组矩阵的行对应用户
    :param item: 列对应物品
    :return: 对物品的预测评分，返回后用于分数的排序
    """
    n = np.shape(data)[1]  # 得到数据集中的物品种类数据(各个列)
    Totalsim = 0.0  # 初始化两个评分值
    TotalratSim = 0.0  # 相似性总和变量初始化
    # 遍历给定的用户行中的每个物品
    # 即（对用户评过分的物品进行遍历，并将它与其他物品进行比较），计算相似度
    for j in range(n):
        # 得到给定的用户 user 对商品的评分
        Rating_user = data[user, j]
        # 只对 评价过的商品 和 不是自己的商品 求相似度
        if Rating_user != 0 and j != item:
            # 计算 svd 转换过后矩阵的相似度,物品 item 与物品 j 之间的相似度
            # 相似度的计算方法也会作为一个参数传递给该函数
            Similarity = simMeas(FormedItems[item, :], FormedItems[j, :])
            Totalsim += Similarity  # 对相似度不断累加求和
            TotalratSim += Similarity * Rating_user  # 对相似度及对应评分值乘积求和
    if Totalsim == 0:
        return 0
    else:
        return TotalratSim / Totalsim  # 得到对物品的预测评分，返回后用于分数的排序

def recommend(data, user, FormedItems, N, simMeas):
    # 为未评价的物品建立一个用户未评分 item 的列表
    unratedItems = np.array(np.nonzero(data[user, :] == 0))[0]
    if len(unratedItems) == 0:
        return "你已评价完所有物品"  # 若都已经评过分，则退出
    Scoresitem = []
    for item in unratedItems:  # 对未评分的物品 item，都计算其预测评分
        # 计算评价值
        estimatedScore = svd_predict(data, user, simMeas, FormedItems,
                                     item)
        Scoresitem.append((item, estimatedScore))  # 记录商品及评价值
    Scoresitem = sorted(Scoresitem, key=lambda x: x[1], reverse=True)  # 按照得分逆序排序
    return Scoresitem[:N]  # 返回前 N 个评分的物品名

def recommend_predict():
    user_item = loadExData()  # 读取数据
    percentage = 0.9  # 奇异值平方和的百分比
    user = 1  # 预测的用户
    n = 4  # 推荐个数
    FormedItems = svd_item(user_item, percentage)  # 获得 SVD 降维后的物品
    
    s_t = time.time()
    simMeas = cosSim  # 相似度
    r1 = recommend(user_item, user, FormedItems, n, simMeas)
    print('利用余弦相似度计算距离，进行的奇异值分解推荐：')
    print("按相似度推荐的物品编号为：", r1, "\n 用时:", time.time() - s_t)
    
    s_t = time.time()
    simMeas = ecludSim
    r2 = recommend(user_item, user, FormedItems, n, simMeas)
    print('利用欧氏距离计算距离，进行的奇异值分解推荐：')
    print("按相似度推荐的物品编号为：", r2, "\n 用时:", time.time() - s_t)
    
    s_t = time.time()
    simMeas = pearsSim
    r3 = recommend(user_item, user, FormedItems, n, simMeas)
    print('利用皮尔逊相关系数计算距离，进行的奇异值分解推荐：')
    print("按相似度推荐的物品编号为：", r3, "\n 用时:", time.time() - s_t)

if __name__ == "__main__":
    recommend_predict()

import numpy as np
import pandas as pd
 
# 1、读入数据集 header = [用户 id, 电影 id, 评分(取整), 用户提交时间所用秒数]
header = ["user_id","item_id","rating","timestamp"]
data = pd.read_csv("u.data", sep="\t", names=header)  # 以 csv 文件格式读取 u.data, 分隔符是\t, 列名是 header
# 2、生成用户—物品评分矩阵
# 检查是否有重复的用户物品打分记录(数据清洗)
# data.duplicated()   # 返回布尔型数据，告诉重复值的位置
data.duplicated(subset = ["user_id","item_id"]).sum()  # 返回重复值的个数
item_id_user = data.groupby("item_id").count()["user_id"]  # 返回表格(物品 id, 评分用户次数)
print(item_id_user)
# 构建用户物品矩阵
users_num = data.user_id.max()  # 选择最大的 id, 可以剔除重复数据
items_num = data.item_id.max()
user_item_rating = np.zeros((users_num,items_num))
for line in data.itertuples():  # itertuples()：将 DataFrame 迭代成元组
    # 以元组的方式赋值
    user_item_rating[line[1] - 1, line[2] - 1] = line[3]
# 生成用户——电影评分矩阵存储成文本文件, 数据为 user_item_rating, 分隔符为，
np.savetxt("评分 2.csv", user_item_rating, delimiter = ",")
# 输出 u.data 中的前 5 行内容
data.head()

# 输出 u.data 中的大小
print("数据集的大小", data.shape)
# 输出客户数和电影数
print("客户数 =", users_num)
print("电影数 =", items_num)
print("客户数 * 电影数:", users_num * items_num)
# 查看生成的 user_item_rating 非零元素
print("user_item_rating 中的非零元素个数", len(user_item_rating.nonzero()[1]))
print("user_item_rating 中的非零元素", user_item_rating.nonzero()[1])
# 查看生成的 user_item_rating 矩阵的稀疏性
sparsity = round(len(user_item_rating.nonzero()[1]) / float(users_num * items_num), 3)
print("user_item_rating 矩阵的稀疏性：", sparsity)
print("user_item_rating 矩阵的大小", user_item_rating.shape)
# 以表格形式显示用户—电影评分表矩阵, 列名为电影, 行名为用户
pd.DataFrame(user_item_rating)