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之间的相似度也可以简单通过这种方式进行计算