奇异值分解SVD 原理+作业

import numpy as np


def get_data2():
    return np.array([[2, 0],
                     [0, 1 / np.sqrt(2)],
                     [0, 1 / np.sqrt(2)], ])


def get_data():
    return np.array([[1, 0, 0, 0, 2],
                     [0, 0, 3, 0, 0],
                     [0, 0, 0, 0, 0],
                     [0, 4, 0, 0, 0]])


def get_eigenvalue(A):
    return np.linalg.eigvals(A)


def get_U(A):
    return np.linalg.eig(A.dot(A.T))


def get_V(A):
    return np.linalg.eig(A.T.dot(A))


def SVD():
    sigma, V = get_V(A)
    sigma, V, length = bubble_sort(sigma, V)
    sigma2, U = get_U(A)
    sigma, U, _ = bubble_sort(sigma2, U)
    S = np.zeros((m, n))
    for i in range(length):
        S[i][i] = np.sqrt(sigma[i])

    # print(S)
    # U = np.zeros((m, m))
    # print(U.shape)
    for i in range(length):
        # print((1 / np.sqrt(sigma[i])) * np.dot(A, V[:, i]))
        U[:, i] = (1 / np.sqrt(sigma[i])) * np.dot(A, V[:, i])
    return U, S, V


def bubble_sort(sigma, B):
    """
    对奇异值进行排序
    :param sigma:
    :param B:
    :return:
    """
    length = len(sigma)
    for i in range(length - 1):
        # i表示比较多少轮
        for j in range(length - i - 1):
            if sigma[j] < sigma[j + 1]:
                sigma[j], sigma[j + 1] = sigma[j + 1], sigma[j]
                B[:, [j, j + 1]] = B[:, [j + 1, j]]
    temp = 0
    for i in range(length):
        if sigma[i] > 0:
            temp = temp + 1
    return sigma, B, temp


# 获取数据
A = get_data2()
m = A.shape[0]
n = A.shape[1]
k = min(m, n)

U, S, V = SVD()
temp2 = np.dot(np.dot(U, S), V.T)
print("SVD-- \n U=\n{}\n Z=\n{}\n V=\n{}".format(U, S, V))
print("*" * 10)
print(temp2)

SVD-- 
 U=
[[ 1.          0.          0.        ]
 [ 0.          0.70710678  0.70710678]
 [ 0.          0.70710678 -0.70710678]]
 Z=
[[2. 0.]
 [0. 1.]
 [0. 0.]]
 V=
[[1. 0.]
 [0. 1.]]
**********
[[2.         0.        ]
 [0.         0.70710678]
 [0.         0.70710678]]

# 人脸识别是一个分类问题
# svc 支持向量解决分类问题
import cv2
import numpy as np
import os

data_path = r"att_faces"
train_data = []
test_data = []
image = []
sigma_data = []

# 使用50个特征值作为该图像的特征信息
K = 80
print("选取了{}个特征".format(K))


def read_image():
    """
    加载图片信息
    :return:
    """
    global train_data, test_data
    root_path = os.listdir(data_path)
    for d in root_path:
        s_path = os.path.join(data_path, d)
        for idx, image_path in enumerate(os.listdir(s_path)):
            # 因为是二维图,所以是二维的 [112,92]
            img = cv2.imread(os.path.join(s_path, image_path), cv2.IMREAD_GRAYSCALE)
            image.append(img)
    train_data = image[0::2]
    test_data = image[1::2]


def train():
    """
    进行训练,训练的目的就是把40 张图片的所有 特征值提取出来，放进sigma_data
    :return:
    """

    for image in train_data:
        # 数据进行展示
        u, sigma, v = np.linalg.svd(image)
        # 对sigma 从小到大排序
        sigma = np.sort(sigma)
        # 选取特征值K个最大特征值作为Sm_i的特征值
        sigma_data.append(sigma[-K:])

    print("训练结束")


def test():
    """
    用提前准备好的图片 做最近邻算法的比较,和谁的最近邻 小

    :return:
    """
    # 分类正确的个数
    acc = 0
    for idx, image in enumerate(test_data):
        u, sigma, v = np.linalg.svd(image)
        # 对sigma 从小到大排序
        sigma = np.sort(sigma)
        # 选取特征值K个最大特征值作为Sm_i的特征值
        sigma = sigma[-K:]
        m = get_index(sigma)
        raw = int(idx / 5) + 1
        predict = int(m / 5) + 1
        if raw == predict:
            acc += 1
            print("这张图预测为{},预测正确".format(predict, raw))
        else:
            print("这张图预测为{},预测错误,本来是{}".format(predict, raw))

    print("最终准确率{}%,--[{}/{}]".format(100 * acc / len(test_data), acc, len(test_data)))
    # 使用


def get_index(sigma):
    """
    求出最小近邻的 所在是索引值
    :param sigma: 测试图像的前 K 个最大特征值
    :return:
    """
    index = []
    for i in sigma_data:
        # 最小近邻，其实就是求第二范数
        index.append(np.linalg.norm(i - sigma))
    return np.argmin(index)


# 加载数据
read_image()
# print(test_data)

# 训练
train()
# 测试
test()

这张图预测为21,预测错误,本来是38
这张图预测为38,预测正确
这张图预测为39,预测正确
这张图预测为39,预测正确
这张图预测为39,预测正确
这张图预测为39,预测正确
这张图预测为39,预测正确
这张图预测为34,预测错误,本来是40
这张图预测为40,预测正确
这张图预测为40,预测正确
这张图预测为40,预测正确
这张图预测为40,预测正确
最终准确率73.0%,--[146/200]