# -*- coding: utf8 -*-
#
from typing import List
from unittest import TestCase

import torch
from torch.nn.utils.rnn import pad_sequence
from transformers import AutoTokenizer, AutoModel, PreTrainedTokenizerBase


def tokenize(form: List[List[str]], tokenizer: PreTrainedTokenizerBase, max_length: int, char_base: bool = False):
    """

    Args:
        form:
        tokenizer:
        max_length:
        char_base: 这里指的是form[即 word]是否是字级别的

    Returns:

    """
    res = tokenizer.batch_encode_plus(
        form,
        is_split_into_words=True,
        max_length=max_length,
        truncation=True,
    )
    result = res.data
    # 可用于长度大于指定长度过滤, overflow指字长度大于指定max_length，如果有cls,sep，那么就算上这个
    result['overflow'] = [len(encoding.overflowing) > 0 for encoding in res.encodings]
    if not char_base:
        word_index = []
        for encoding in res.encodings:
            word_index.append([])

            last_word_idx = -1
            current_length = 0
            for word_idx in encoding.word_ids[1:-1]:
                if word_idx != last_word_idx:
                    word_index[-1].append(current_length)

                current_length += 1
                last_word_idx = word_idx
        result['word_index'] = word_index
        result['word_attention_mask'] = [[True] * len(index) for index in word_index]
    return result


class TestSample(TestCase):
    def test_max_length(self):
        """
        测试max_length overflow情况
        :return:
        """
        pass

    def test_sample(self):
        form = [
            ['我', '呀'],
            ['我', '小明', '呀']
        ]

        tokenizer = AutoTokenizer.from_pretrained('hfl/chinese-electra-180g-small-discriminator')
        result = tokenize(form, tokenizer, 6)
        model = AutoModel.from_pretrained('hfl/chinese-electra-180g-small-discriminator')

        input_ids = pad_sequence([torch.tensor(input_ids) for input_ids in result['input_ids']], batch_first=True)
        token_type_ids = pad_sequence([torch.tensor(token_type_ids) for token_type_ids in result['token_type_ids']],
                                      batch_first=True)
        attention_mask = pad_sequence([torch.tensor(attention_mask) for attention_mask in result['attention_mask']],
                                      batch_first=True)

        # tensor([[ 101, 2769, 1435,  102,    0,    0],
        #         [ 101, 2769, 2207, 3209, 1435,  102]])

        # 1. 获取bert output.
        bert_out = model(input_ids=input_ids, token_type_ids=token_type_ids, attention_mask=attention_mask)
        seq_out = bert_out[0]

        word_index = pad_sequence([torch.tensor(word_index) for word_index in result['word_index']], batch_first=True)

        # 2. 获取词首字向量，包括cls开头
        word_out = torch.cat([seq_out[:, :1, :], torch.gather(
            seq_out[:, 1:, :], dim=1, index=word_index.unsqueeze(-1).expand(-1, -1, seq_out.size(-1))
        )], dim=1)

        word_attention_mask = pad_sequence(
            [torch.tensor(word_attention_mask) for word_attention_mask in result['word_attention_mask']],
            batch_first=True)

        # 这里方便view
        # 1. ['我', '呀']
        self.assertTrue((seq_out[0][0] == word_out[0][0]).all())  # cls
        self.assertTrue((seq_out[0][1] == word_out[0][1]).all())  # 我
        self.assertTrue((seq_out[0][2] == word_out[0][2]).all())  # 呀

        self.assertTrue((word_out[0][1] == word_out[0][3]).all())  # 填充位

        # 2. ['我', '小明', '呀']
        self.assertTrue((seq_out[1][0] == word_out[1][0]).all())  # cls
        self.assertTrue((seq_out[1][1] == word_out[1][1]).all())  # 我
        self.assertTrue((seq_out[1][2] == word_out[1][2]).all())  # 小明
        self.assertTrue((seq_out[1][4] == word_out[1][3]).all())  # 呀

        # 3. Note: word_out的时候concat了seq_out[:, :1, :](cls)，所以word_out的长度比word_attention_mask大1
        self.assertEqual(word_out.size(1), word_attention_mask.size(1) + 1)

        # 4. 获取每个词对应的向量
        result = word_out[:, 1:, :][word_attention_mask]
        result2 = result.split(word_attention_mask.sum(1).tolist())
        self.assertEqual(len(result2[0]), 2)
        self.assertEqual(len(result2[1]), 3)

import torch
from transformers import AutoTokenizer


def encoder_texts(texts: List[List[str]], tokenizer):
    # 统计句子中最大的词长度
    fix_len = max([max([len(word) for word in text]) for text in texts])

    matrix = []
    for text in texts:
        vector = []

        text = [tokenizer.cls_token, *text, tokenizer.sep_token]
        input_ids = tokenizer.batch_encode_plus(
            text,
            add_special_tokens=False,
        )['input_ids']

        for _input_ids in input_ids:
            # 修复例如: texts = [['\ue5f1\ue5f1\ue5f1\ue5f1']] 这种情况
            _input_ids = _input_ids or [tokenizer.unk_token_id]
            vector.append(_input_ids + (fix_len - len(_input_ids)) * [tokenizer.pad_token_id])
        matrix.append(torch.tensor(vector, dtype=torch.long))
    return pad_sequence(matrix, batch_first=True)


if __name__ == '__main__':
    texts = [
        ['我', '爱中国'],
        ['我', '爱', '中国']
    ]
    tokenizer = AutoTokenizer.from_pretrained('ckiplab/albert-tiny-chinese')
    print(encoder_texts(texts, tokenizer))

# -*- coding: utf-8 -*-

import torch
import torch.nn as nn
from supar.modules.scalar_mix import ScalarMix
from supar.utils.fn import pad

# pad 等价于 pad_sequence。

# from torch.nn.utils.rnn import pad_sequence

class TransformerEmbedding(nn.Module):
    r"""
    A module that directly utilizes the pretrained models in `transformers`_ to produce BERT representations.
    While mainly tailored to provide input preparation and post-processing for the BERT model,
    it is also compatible with other pretrained language models like XLNet, RoBERTa and ELECTRA, etc.

    Args:
        model (str):
            Path or name of the pretrained models registered in `transformers`_, e.g., ``'bert-base-cased'``.
        n_layers (int):
            The number of BERT layers to use. If 0, uses all layers.
        n_out (int):
            The requested size of the embeddings. If 0, uses the size of the pretrained embedding model. Default: 0.
        stride (int):
            A sequence longer than max length will be splitted into several small pieces
            with a window size of ``stride``. Default: 10.
        pooling (str):
            Pooling way to get from token piece embeddings to token embedding.
            ``first``: take the first subtoken. ``last``: take the last subtoken. ``mean``: take a mean over all.
            Default: ``mean``.
        pad_index (int):
            The index of the padding token in BERT vocabulary. Default: 0.
        dropout (float):
            The dropout ratio of BERT layers. Default: 0. This value will be passed into the :class:`ScalarMix` layer.
        requires_grad (bool):
            If ``True``, the model parameters will be updated together with the downstream task. Default: ``False``.

    .. _transformers:
        https://github.com/huggingface/transformers
    """

    def __init__(self, model, n_layers=4, n_out=0, stride=256, pooling='mean', pad_index=0, dropout=0, requires_grad=True):
        super().__init__()

        from transformers import AutoConfig, AutoModel, AutoTokenizer
        self.bert = AutoModel.from_pretrained(model, config=AutoConfig.from_pretrained(model, output_hidden_states=True))
        self.bert = self.bert.requires_grad_(requires_grad)

        self.model = model
        self.n_layers = n_layers or self.bert.config.num_hidden_layers
        self.hidden_size = self.bert.config.hidden_size
        self.n_out = n_out or self.hidden_size
        self.stride = stride
        self.pooling = pooling
        self.pad_index = pad_index
        self.dropout = dropout
        self.requires_grad = requires_grad
        self.max_len = int(max(0, self.bert.config.max_position_embeddings) or 1e12) - 2

        self.tokenizer = AutoTokenizer.from_pretrained(model)

        self.scalar_mix = ScalarMix(self.n_layers, dropout)
        self.projection = nn.Linear(self.hidden_size, self.n_out, False) if self.hidden_size != n_out else nn.Identity()

    def __repr__(self):
        s = f"{self.model}, n_layers={self.n_layers}, n_out={self.n_out}, "
        s += f"stride={self.stride}, pooling={self.pooling}, pad_index={self.pad_index}"
        if self.dropout > 0:
            s += f", dropout={self.dropout}"
        if self.requires_grad:
            s += f", requires_grad={self.requires_grad}"

        return f"{self.__class__.__name__}({s})"

    def forward(self, subwords):
        r"""
        Args:
            subwords (~torch.Tensor): ``[batch_size, seq_len, fix_len]``.
        Returns:
            ~torch.Tensor:
                BERT embeddings of shape ``[batch_size, seq_len, n_out]``.
        """

        mask = subwords.ne(self.pad_index)
        lens = mask.sum((1, 2))
        # [batch_size, n_subwords]
        subwords = pad(subwords[mask].split(lens.tolist()), self.pad_index, padding_side=self.tokenizer.padding_side)
        bert_mask = pad(mask[mask].split(lens.tolist()), 0, padding_side=self.tokenizer.padding_side)

        # return the hidden states of all layers
        bert = self.bert(subwords[:, :self.max_len], attention_mask=bert_mask[:, :self.max_len].float())[-1]
        # [n_layers, batch_size, max_len, hidden_size]
        bert = bert[-self.n_layers:]
        # [batch_size, max_len, hidden_size]
        bert = self.scalar_mix(bert)
        # [batch_size, n_subwords, hidden_size]
        for i in range(self.stride, (subwords.shape[1]-self.max_len+self.stride-1)//self.stride*self.stride+1, self.stride):
            part = self.bert(subwords[:, i:i+self.max_len], attention_mask=bert_mask[:, i:i+self.max_len].float())[-1]
            bert = torch.cat((bert, self.scalar_mix(part[-self.n_layers:])[:, self.max_len-self.stride:]), 1)

        # [batch_size, seq_len]
        bert_lens = mask.sum(-1)
        bert_lens = bert_lens.masked_fill_(bert_lens.eq(0), 1)
        # [batch_size, seq_len, fix_len, hidden_size]
        embed = bert.new_zeros(*mask.shape, self.hidden_size).masked_scatter_(mask.unsqueeze(-1), bert[bert_mask])
        # [batch_size, seq_len, hidden_size]
        if self.pooling == 'first':
            embed = embed[:, :, 0]
        elif self.pooling == 'last':
            embed = embed.gather(2, (bert_lens-1).unsqueeze(-1).repeat(1, 1, self.hidden_size).unsqueeze(2)).squeeze(2)
        else:
            embed = embed.sum(2) / bert_lens.unsqueeze(-1)
        embed = self.projection(embed)

        return embed

def AutogradRNN(mode, input_size, hidden_size, num_layers=1, batch_first=False,
                dropout=0, train=True, bidirectional=False, variable_length=False,
                dropout_state=None, flat_weight=None):
    # 使用不同的cell进行计算，每一层rnn layer即一个cell。
    if mode == 'RNN_RELU':
        cell = RNNReLUCell
    elif mode == 'RNN_TANH':
        cell = RNNTanhCell
    elif mode == 'LSTM':
        cell = LSTMCell
    elif mode == 'GRU':
        cell = GRUCell
    else:
        raise Exception('Unknown mode: {}'.format(mode))
    # rec_factory即表示Recurrent，就是第四步的函数
    rec_factory = variable_recurrent_factory if variable_length else Recurrent

    if bidirectional:
        # 可以看到哦，反向就是进行reverse一下
        # 对应代码：steps = range(input.size(0) - 1, -1, -1) if reverse else range(input.size(0))
        # 意思就是从最后一个时刻反向进行更新hidden_size（不同时刻的y）。
        layer = (rec_factory(cell), rec_factory(cell, reverse=True))
    else:
        layer = (rec_factory(cell),)
    # 这地方疯狂使用闭包...
    func = StackedRNN(layer,
                      num_layers,
                      (mode == 'LSTM'),
                      dropout=dropout,
                      train=train)

    def forward(input, weight, hidden, batch_sizes):
        if batch_first and not variable_length:
            # 囔，这里就会batch_size 和  sequence_length对调
            input = input.transpose(0, 1)

        nexth, output = func(input, hidden, weight, batch_sizes)

        if batch_first and not variable_length:
            output = output.transpose(0, 1)

        return output, nexth

    return forward

def StackedRNN(inners, num_layers, lstm=False, dropout=0, train=True):
    
    """
     拿到每一层Recurrent layer计算出来的结果，进行concat到一起进行返回
     
     inner表示 Recurrent，代码如下

    """

    num_directions = len(inners)
    total_layers = num_layers * num_directions

    def forward(input, hidden, weight, batch_sizes):
        """
        input: 3, 32, 30 (sequence_length, batch_size, embedding input hidden_size),
        hidden: 10, 32, 4 (num_layers, batch_size, output hidden_size),
        """
        assert(len(weight) == total_layers)
        next_hidden = []

        if lstm:
            hidden = list(zip(*hidden))
        # 遍历rnn中num_layers
        for i in range(num_layers):
            all_output = []
            for j, inner in enumerate(inners): # inner表示 Recurrent，代码如下
                l = i * num_directions + j

                hy, output = inner(input, hidden[l], weight[l], batch_sizes)
                next_hidden.append(hy)
                all_output.append(output)

            input = torch.cat(all_output, input.dim() - 1)

            if dropout != 0 and i < num_layers - 1:
                input = F.dropout(input, p=dropout, training=train, inplace=False)

        if lstm:
            next_h, next_c = zip(*next_hidden)
            next_hidden = (
                torch.cat(next_h, 0).view(total_layers, *next_h[0].size()),
                torch.cat(next_c, 0).view(total_layers, *next_c[0].size())
            )
        else:
            next_hidden = torch.cat(next_hidden, 0).view(
                total_layers, *next_hidden[0].size())

        return next_hidden, input

    return forward

def Recurrent(inner, reverse=False):
    """
    表示单层layer的计算
    """
    def forward(input, hidden, weight, batch_sizes):
        """
        input: 3, 32, 30
        hidden: 32, 4 (表示遍历每一个单独的rnn进来，一共10次)
        weight:List[  (4, 30), (4,4), (4, ), (4, ) ]
        """
        output = []
        steps = range(input.size(0) - 1, -1, -1) if reverse else range(input.size(0))
        for i in steps: # steps为3,因为sequence_length为3
            hidden = inner(input[i], hidden, *weight) # hidden就代表上一个时刻的输出， inner为RNNTanhCell，代码如下
            # hack to handle LSTM
            output.append(hidden[0] if isinstance(hidden, tuple) else hidden)

        if reverse:
            output.reverse()
        output = torch.cat(output, 0).view(input.size(0), *output[0].size())
        # 此处hidden就代表最后一个时刻的输出(32, 4)，output表示每一个时刻的输出(3, 32, 4)
        # torch.any(output[-1,:,:] == hidden)
        return hidden, output

    return forward

# 针对rnn
def RNNTanhCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None):
    """
    input: 32, 30
    hidden: 32, 4
    w_ih: 4,30
    w_hh: 4,4
    b_ih: 4
    b_hh: 4
    """
    hy = torch.tanh(F.linear(input, w_ih, b_ih) + F.linear(hidden, w_hh, b_hh))
    return hy

# 针对lstm cell.
def LSTMCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None):
    """
    input: (32, 30)
    hidden: ( (32, 4), (32, 4) )
    w_ih: (16, 30)
    w_hh: (16, 4)
    b_ih: (16, )
    b_hh: (16, )
    """
    if input.is_cuda: # 自行忽略此处代码
        igates = F.linear(input, w_ih)
        hgates = F.linear(hidden[0], w_hh)
        state = fusedBackend.LSTMFused.apply
        return state(igates, hgates, hidden[1]) if b_ih is None else state(igates, hgates, hidden[1], b_ih, b_hh)

    hx, cx = hidden
    # 看到么，也是rnn公式哦
    gates = F.linear(input, w_ih, b_ih) + F.linear(hx, w_hh, b_hh)
    # 但是此处不一样了，在第一维分割4份出来
    ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1)
    # 看到下面这几行公式么，为啥子就能解决梯度消失呢？
    # 神不神奇，意不意外
    ingate = torch.sigmoid(ingate)
    forgetgate = torch.sigmoid(forgetgate)
    cellgate = torch.tanh(cellgate)
    outgate = torch.sigmoid(outgate)

    cy = (forgetgate * cx) + (ingate * cellgate)
    hy = outgate * torch.tanh(cy)
    # hy: (32,4), (32,4)
    return hy, cy

# 针对gru
def GRUCell(input, hidden, w_ih, w_hh, b_ih=None, b_hh=None):

    if input.is_cuda:
        gi = F.linear(input, w_ih)
        gh = F.linear(hidden, w_hh)
        state = fusedBackend.GRUFused.apply
        return state(gi, gh, hidden) if b_ih is None else state(gi, gh, hidden, b_ih, b_hh)

    # 这里就变了哦
    gi = F.linear(input, w_ih, b_ih)
    gh = F.linear(hidden, w_hh, b_hh)

    i_r, i_i, i_n = gi.chunk(3, 1)
    h_r, h_i, h_n = gh.chunk(3, 1)

    resetgate = torch.sigmoid(i_r + h_r)
    inputgate = torch.sigmoid(i_i + h_i)
    newgate = torch.tanh(i_n + resetgate * h_n)
    hy = newgate + inputgate * (hidden - newgate)

    return hy

# -*- coding: utf8 -*-
#
from torch.nn import Embedding, Sigmoid, Linear
from torch.nn.modules.rnn import RNN

import torch
from torch.nn import BCELoss
from torch.optim import RMSprop


class RNNModel(torch.nn.Module):
    def __init__(self):
        super(RNNModel, self).__init__()
        self.embed = Embedding(6, 30)
        self.rnn = RNN(input_size=30, hidden_size=4, batch_first=True, num_layers=10)
        self.linear = Linear(4, 1)

    def forward(self, input):
        input = self.embed(input)
        # rnn_out: (32, 3, 4) 返回batch_size下每个时刻(sequence_length)的最终输出
        # _ : (10, 32, 4) 表示batch_size下每个rnn layer最后一个时刻的输出
        rnn_out, _ = self.rnn(input)
        y_pred = self.linear(_.sum(0))
        return y_pred


class RNNDemo(object):
    def __init__(self):
        self.model = RNNModel()

        self.optim = RMSprop(self.model.parameters())

    def loss(self, y_pred, y_true):
        y_pred = Sigmoid()(y_pred)
        return BCELoss()(y_pred, y_true.float())

    def train(self, x, y):
        for i in range(100):
            for _x, _y in zip(x, y):
                _x = _x.repeat(32, 1)
                _y = _y.repeat(32, 1)
                y_pred = self.model(_x)
                loss = self.loss(y_pred, _y)
                loss.backward()
                print(loss.item())
                self.optim.step()
                self.optim.zero_grad()


if __name__ == '__main__':
    train_data = [
        (['A', 'B', 'C'], 'right'),
        (['C', 'D', 'E'], 'false')
    ]
    id_map = {
        'A': 1,
        'B': 2,
        'C': 3,
        'D': 4,
        'E': 5,
        'right': 6,
        'false': 7

    }
    rnn = RNNDemo()
    rnn.train(
        [torch.tensor([id_map[i] for i in sample[0]]).reshape(1, 3) for sample in train_data],
        [torch.tensor(id_map[sample[1]]).reshape(1, 1) for sample in train_data]
    )

import numpy as np
import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt
%matplotlib inline

# create state space and initial state probabilities

states = ['sleeping', 'eating', 'pooping']
pi = [0.35, 0.35, 0.3]
state_space = pd.Series(pi, index=states, name='states')
print(state_space)
print(state_space.sum())

q_df = pd.DataFrame(columns=states, index=states)
q_df.loc[states[0]] = [0.4, 0.2, 0.4]
q_df.loc[states[1]] = [0.45, 0.45, 0.1]
q_df.loc[states[2]] = [0.45, 0.25, .3]

print(q_df)

q = q_df.values
print('\n', q, q.shape, '\n')
print(q_df.sum(axis=1))

hidden_states = ['healthy', 'sick']
pi = [0.5, 0.5]
state_space = pd.Series(pi, index=hidden_states, name='states')
print(state_space)
print('\n', state_space.sum())


a_df = pd.DataFrame(columns=hidden_states, index=hidden_states)
a_df.loc[hidden_states[0]] = [0.7, 0.3]
a_df.loc[hidden_states[1]] = [0.4, 0.6]

print(a_df)

a = a_df.values
print('\n', a, a.shape, '\n')
print(a_df.sum(axis=1))

# -*- coding: utf8 -*-

import numpy as np

import pandas as pd



def viterbi(pi, a, b, obs):
    """Viterbi algorithm for solving the uncovering problem

    Notebook: C5/C5S3_Viterbi.ipynb

    Args:
        a (np.ndarray): State transition probability matrix of dimension I x I
        pi (np.ndarray): Initial state distribution  of dimension I
        b (np.ndarray): Output probability matrix of dimension I x K
        obs (np.ndarray): Observation sequence of length N

    Returns:
        path (np.ndarray): Optimal state sequence of length N
        delta (np.ndarray): Accumulated probability matrix
        E (np.ndarray): Backtracking matrix
    """
    n_states = a.shape[0]  # Number of states
    T = len(obs)  # Length of observation sequence

    # Initialize D and E matrices
    delta = np.zeros((n_states, T))
    E = np.zeros((n_states, T - 1)).astype(np.int32)
    delta[:, 0] = np.multiply(pi, b[:, obs[0]])

    # Compute D and E in a nested loop
    print('start walk forward'.center(30, '-'))
    for n in range(1, T):
        for i in range(n_states):
            temp_product = np.multiply(a[:, i], delta[:, n - 1])
            delta[i, n] = np.max(temp_product) * b[i, obs[n]]
            E[i, n - 1] = np.argmax(temp_product)
            print('s={s} and t={t}: phi[{s}, {t}] = {phi}'.format(s=i, t=n, phi=E[i, n - 1]))

    # Backtracking
    print('start backtrace'.center(30, '-'))
    path = np.zeros(T).astype(np.int32)
    path[-1] = np.argmax(delta[:, -1])
    for n in range(T - 2, -1, -1):
        path[n] = E[int(path[n + 1]), n]
        print('path[{}] = {}'.format(n, path[n]))
    return path, delta, E




states = ['sleeping', 'eating', 'pooping']
pi = [0.35, 0.35, 0.3]
state_space = pd.Series(pi, index=states, name='states')

q_df = pd.DataFrame(columns=states, index=states)
q_df.loc[states[0]] = [0.4, 0.2, 0.4]
q_df.loc[states[1]] = [0.45, 0.45, 0.1]
q_df.loc[states[2]] = [0.45, 0.25, .3]

q = q_df.values

hidden_states = ['healthy', 'sick']
pi = np.array([0.5, 0.5])
state_space = pd.Series(pi, index=hidden_states, name='states')

a_df = pd.DataFrame(columns=hidden_states, index=hidden_states)
a_df.loc[hidden_states[0]] = [0.7, 0.3]
a_df.loc[hidden_states[1]] = [0.4, 0.6]

a = a_df.values

observable_states = states

b_df = pd.DataFrame(columns=observable_states, index=hidden_states)
b_df.loc[hidden_states[0]] = [0.2, 0.6, 0.2]
b_df.loc[hidden_states[1]] = [0.4, 0.1, 0.5]

b = b_df.values

obs_map = {'sleeping': 0, 'eating': 1, 'pooping': 2}
obs = np.array([1, 1, 2, 1, 0, 1, 2, 1, 0, 2, 2, 0, 1, 0, 1])
inv_obs_map = dict((v,k) for k, v in obs_map.items())
obs_seq = [inv_obs_map[v] for v in list(obs)]

path, delta, phi = viterbi(pi, a, b, obs)
print('\nsingle best state path: \n', path)
print('delta:\n', delta)
print('phi:\n', phi)


state_map = {0:'healthy', 1:'sick'}
state_path = [state_map[v] for v in path]

print(pd.DataFrame()
 .assign(Observation=obs_seq)
 .assign(Best_Path=state_path))

# -*- coding: utf8 -*-
#
import numpy as np
import pandas as pd
from scipy.sparse import csc_matrix
from scipy.sparse.linalg import svds

# value为用户对不同的item的喜欢程度
df = pd.DataFrame({"军事": [0, 10, 7], '言情': [10, 3, 0], '动漫': [5, 3, 0], '小说': [3, 5, 0]}, dtype='float64')
#    军事    言情   动漫   小说
# 0   0.0  10.0  5.0  3.0
# 1  10.0   3.0  3.0  5.0
# 2   7.0   0.0  0.0  0.0
# 可以看到user0喜欢言情和动漫，用户1、2喜欢军事

U, s, Vt = svds(csc_matrix(df), k=2) # K可以理解成用多少feature来进行表示，主要用于降维和减少稀疏性，超参数

matrix_new = U.dot(np.diag(s)).dot(Vt)
print(matrix_new)
# [[-0.1314746 ,  9.7949323 ,  5.08515349,  3.45149176],
# [10.28341738,  3.44206066,  2.81643619,  4.02672754],
# [ 6.55257518, -0.6978715 ,  0.28978818,  1.53648395]] # 推荐顺序-> 军事,小说,动漫

# ################################ 推荐
item_user_matrix = matrix_new.transpose()
svd_df = pd.DataFrame(item_user_matrix, columns=['user0', 'user1', 'user2'], index=df.columns)
svd_df['user2'].sort_values(ascending=False)


# Out[18]:
# 军事    6.552575
# 小说    1.536484
# 动漫    0.289788
# 言情   -0.697871
# Name: 2, dtype: float64

# ###################################### 计算用户喜好相似度
def cos(vec1, vec2):
    return vec1.dot(vec2) / np.linalg.norm(vec1) * np.linalg.norm(vec2)


for i in range(U.shape[0]):
    for j in range(i + 1, U.shape[0]):
        vec1 = U[i, :]
        vec2 = U[j, :]
        print(f'User{i}和User{j}的相似度:{cos(vec1, vec2)}')
# User0和User1的相似度:0.11017178104828797
# User0和User2的相似度:-0.11652231240752381
# User1和User2的相似度:0.28527719555421444

# 那同理，item之间的相似度也可以简单通过这种方式进行计算