Помогите найти НС сверточную и рекуррентную но без Керас И Тезорфлоу, а только с Numpy

Свёрточная нейронная сеть (CNN)
1. Реализуйте операцию свёртки (Convolution):

 import numpy as np 
 
def conv2d(X, W, b, stride=1, padding=0): 
    n_H, n_W = X.shape 
    f, f = W.shape 
    n_H_out = (n_H - f + 2 * padding) // stride + 1 
    n_W_out = (n_W - f + 2 * padding) // stride + 1 
 
    X_padded = np.pad(X, ((padding, padding), (padding, padding)), mode='constant') 
 
    out = np.zeros((n_H_out, n_W_out)) 
    for i in range(0, n_H_out): 
        for j in range(0, n_W_out): 
            vert_start = i * stride 
            vert_end = vert_start + f 
            horiz_start = j * stride 
            horiz_end = horiz_start + f 
            out[i, j] = np.sum(X_padded[vert_start:vert_end, horiz_start:horiz_end] * W) + b 
             
    return out 
 

2. Реализуйте операцию pooling:

 def max_pool2d(X, f=2, stride=2): 
    n_H, n_W = X.shape 
    n_H_out = (n_H - f) // stride + 1 
    n_W_out = (n_W - f) // stride + 1 
 
    out = np.zeros((n_H_out, n_W_out)) 
    for i in range(0, n_H_out): 
        for j in range(0, n_W_out): 
            vert_start = i * stride 
            vert_end = vert_start + f 
            horiz_start = j * stride 
            horiz_end = horiz_start + f 
            out[i, j] = np.max(X[vert_start:vert_end, horiz_start:horiz_end]) 
             
    return out 
 

3. Реализуйте полносвязный слой (Fully Connected Layer):

 def fully_connected(X, W, b): 
    return np.dot(X, W) + b 
 

4. Объедините все вместе для простого CNN:

 # Пример данных 
X = np.random.randn(5, 5)  # входное изображение 5x5 
W_conv = np.random.randn(3, 3)  # фильтр 3x3 
b_conv = np.random.randn()  # смещение 
 
# Свёртка 
conv_out = conv2d(X, W_conv, b_conv) 
print("Conv Output:", conv_out) 
 
# Max Pooling 
pool_out = max_pool2d(conv_out) 
print("Max Pool Output:", pool_out) 
 
# Полносвязный слой 
W_fc = np.random.randn(pool_out.size, 1) 
b_fc = np.random.randn() 
fc_out = fully_connected(pool_out.flatten(), W_fc, b_fc) 
print("Fully Connected Output:", fc_out) 
 

Рекуррентная нейронная сеть (RNN)
1. Реализуйте простую RNN клетку:

 def rnn_cell(X_t, h_prev, W_xh, W_hh, b_h): 
    h_next = np.tanh(np.dot(X_t, W_xh) + np.dot(h_prev, W_hh) + b_h) 
    return h_next 
 

2. Объедините все вместе для простой RNN:

 # Пример данных 
timesteps = 10 
input_dim = 3 
hidden_dim = 5 
 
X = np.random.randn(timesteps, input_dim) 
h_prev = np.zeros((hidden_dim,)) 
 
W_xh = np.random.randn(input_dim, hidden_dim) 
W_hh = np.random.randn(hidden_dim, hidden_dim) 
b_h = np.random.randn(hidden_dim,) 
 
for t in range(timesteps): 
    h_prev = rnn_cell(X[t], h_prev, W_xh, W_hh, b_h) 
    print(f"Hidden state at time step {t}: {h_prev}")