用numpy写一个W-RNN 模型，其中 x 为输入，a、b 为隐藏层， o 为输出，U、V、W、R、T、Q、𝑠1、𝑠2、𝑠3为模型参数， 𝑓1，𝑓2为激活函数（选择 Sigmoid），𝑓3可选用 softmax 函数

下面是使用numpy实现上述W-RNN模型的代码：

import numpy as np

# 定义激活函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def softmax(x):
    exp_x = np.exp(x - np.max(x))
    return exp_x / np.sum(exp_x)

# 定义W-RNN模型
class W_RNN:
    def __init__(self, input_dim, hidden_dim, output_dim):
        # 初始化参数
        self.U = np.random.randn(input_dim, hidden_dim) * 0.01
        self.V = np.random.randn(hidden_dim, output_dim) * 0.01
        self.W = np.random.randn(hidden_dim, hidden_dim) * 0.01
        self.R = np.random.randn(hidden_dim, hidden_dim) * 0.01
        self.T = np.random.randn(hidden_dim, hidden_dim) * 0.01
        self.Q = np.random.randn(hidden_dim, hidden_dim) * 0.01
        self.s1 = np.zeros((1, hidden_dim))
        self.s2 = np.zeros((1, hidden_dim))
        self.s3 = np.zeros((1, hidden_dim))
        
    def forward(self, X):
        # 初始化隐藏状态
        h = np.zeros((X.shape[0], self.W.shape[0]))
        # 初始化加权系数矩阵
        A = np.zeros((X.shape[0], self.W.shape[0]))
        
        for t in range(X.shape[0]):
            # 计算加权系数
            a1 = np.dot(X[t], self.U) + np.dot(h[t-1], self.W) + np.dot(self.s1, self.R)
            a2 = np.dot(h[t-1], self.T) + np.dot(self.s2, self.Q)
            a3 = np.dot(self.s3, self.R)
            A[t] = sigmoid(a1 + a2 + a3)
            # 计算隐藏状态
            h[t] = np.tanh(np.dot(A[t]*h[t-1], self.W))
        # 计算输出结果
        y = softmax(np.dot(h[-1], self.V))
        
        return A, h, y
    
    def backward(self, X, Y, A, h, learning_rate=0.1):
        # 初始化梯度
        dU = np.zeros_like(self.U)
        dV = np.zeros_like(self.V)
        dW = np.zeros_like(self.W)
        dR = np.zeros_like(self.R)
        dT = np.zeros_like(self.T)
        dQ = np.zeros_like(self.Q)
        ds1 = np.zeros_like(self.s1)
        ds2 = np.zeros_like(self.s2)
        ds3 = np.zeros_like(self.s3)
        dh_next = np.zeros_like(h[0])
        dA_next = np.zeros_like(A[0])
        
        for t in reversed(range(X.shape[0])):
            # 计算输出误差
            dy = Y - h[-1].dot(self.V)
            # 计算隐藏状态误差
            dh = dh_next + dy.dot(self.V.T) * (1 - np.power(np.tanh(h[-1]), 2))
            # 计算加权系数误差
            da1 = (dh.dot(self.W.T) + dA_next) * h[t-1] * (1 - h[t-1]) * A[t] * (1 - A[t])
            da2 = (dh.dot(self.W.T) + dA_next) * A[t] * (1 - A[t])
            da3 = (dh.dot(self.W.T) + dA_next) * self.s1 * (1 - self.s1)
            # 更新梯度
            dU += X[t].T.dot(da1)
            dW += h[t-1].T.dot(da1)
            dR += self.s1.T.dot(da1)
            dT += h[t-1].T.dot(da2)
            dQ += self.s2.T.dot(da2)
            dR += self.s3.T.dot(da3)
            dV += h[-1].T.dot(dy)
            ds1 += da1.dot(self.R.T)
            ds2 += da2.dot(self.Q.T)
            ds3 += da3.dot(self.R.T)
            # 计算前一时间步的误差
            dh_next = da1.dot(self.W.T)
            dA_next = da1.dot(h[t-1].T)
        
        # 更新参数
        self.U += learning_rate * dU
        self.V += learning_rate * dV
        self.W += learning_rate * dW
        self.R += learning_rate * dR
        self.T += learning_rate * dT
        self.Q += learning_rate * dQ
        self.s1 += learning_rate * ds1
        self.s2 += learning_rate * ds2
        self.s3 += learning_rate * ds3
        

以上代码实现了一个具有三个加权系数的基本W-RNN模型，其中包括了前向传播和反向传播两个部分，激活函数选择了sigmoid和softmax函数。需要注意的是，以上代码只是一个简单的实现，实际应用中可能需要进行更多的优化和改进。