ilovetools 0.2.19__tar.gz → 0.2.20__tar.gz

{ilovetools-0.2.19/ilovetools.egg-info → ilovetools-0.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ilovetools
-Version: 0.2.19
+Version: 0.2.20
 Summary: A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs
 Home-page: https://github.com/AliMehdi512/ilovetools
 Author: Ali Mehdi
@@ -11,7 +11,7 @@ Project-URL: Repository, https://github.com/AliMehdi512/ilovetools
 Project-URL: Issues, https://github.com/AliMehdi512/ilovetools/issues
 Project-URL: Bug Reports, https://github.com/AliMehdi512/ilovetools/issues
 Project-URL: Source, https://github.com/AliMehdi512/ilovetools
-Keywords: utilities,tools,ai,ml,data-processing,automation,cnn,convolutional-neural-networks,conv2d,pooling,computer-vision,image-processing
+Keywords: utilities,tools,ai,ml,data-processing,automation,rnn,lstm,gru,recurrent-neural-networks,sequence-modeling,nlp
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules

{ilovetools-0.2.19 → ilovetools-0.2.20}/ilovetools/__init__.py

@@ -2,8 +2,8 @@
 ilovetools - A comprehensive Python utility library
 """
 
-__version__ = "0.2.18"
-# release marker: 0.2.18
+__version__ = "0.2.19"
+# release marker: 0.2.19
 __author__ = "Ali Mehdi"
 __email__ = "ali.mehdi.dev579@gmail.com"
 

ilovetools-0.2.20/ilovetools/ml/rnn.py

@@ -0,0 +1,498 @@
+"""
+Recurrent Neural Network Operations
+
+This module provides RNN architectures and operations:
+- Basic RNN (Vanilla RNN)
+- LSTM (Long Short-Term Memory)
+- GRU (Gated Recurrent Unit)
+- Bidirectional RNNs
+- Stacked RNNs
+- Sequence-to-Sequence utilities
+
+All operations support batched inputs and are optimized for sequence processing.
+"""
+
+import numpy as np
+from typing import Tuple, Optional, List
+
+
+# ============================================================================
+# BASIC RNN (VANILLA RNN)
+# ============================================================================
+
+def rnn_cell_forward(
+    x_t: np.ndarray,
+    h_prev: np.ndarray,
+    W_xh: np.ndarray,
+    W_hh: np.ndarray,
+    b_h: np.ndarray
+) -> np.ndarray:
+    """
+    Single timestep of basic RNN cell
+    
+    Formula: h_t = tanh(W_xh @ x_t + W_hh @ h_prev + b_h)
+    
+    Args:
+        x_t: Input at timestep t, shape (batch, input_size)
+        h_prev: Previous hidden state, shape (batch, hidden_size)
+        W_xh: Input-to-hidden weights, shape (input_size, hidden_size)
+        W_hh: Hidden-to-hidden weights, shape (hidden_size, hidden_size)
+        b_h: Hidden bias, shape (hidden_size,)
+        
+    Returns:
+        h_t: New hidden state, shape (batch, hidden_size)
+        
+    Example:
+        >>> x_t = np.random.randn(32, 128)  # (batch, input_size)
+        >>> h_prev = np.random.randn(32, 256)  # (batch, hidden_size)
+        >>> W_xh = np.random.randn(128, 256)
+        >>> W_hh = np.random.randn(256, 256)
+        >>> b_h = np.zeros(256)
+        >>> h_t = rnn_cell_forward(x_t, h_prev, W_xh, W_hh, b_h)
+        >>> print(h_t.shape)  # (32, 256)
+    """
+    h_t = np.tanh(np.dot(x_t, W_xh) + np.dot(h_prev, W_hh) + b_h)
+    return h_t
+
+
+def rnn_forward(
+    x: np.ndarray,
+    h_0: np.ndarray,
+    W_xh: np.ndarray,
+    W_hh: np.ndarray,
+    b_h: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Forward pass through entire RNN sequence
+    
+    Args:
+        x: Input sequence, shape (batch, seq_len, input_size)
+        h_0: Initial hidden state, shape (batch, hidden_size)
+        W_xh: Input-to-hidden weights
+        W_hh: Hidden-to-hidden weights
+        b_h: Hidden bias
+        
+    Returns:
+        Tuple of (outputs, hidden_states)
+        - outputs: shape (batch, seq_len, hidden_size)
+        - hidden_states: shape (batch, seq_len, hidden_size)
+        
+    Example:
+        >>> x = np.random.randn(32, 10, 128)  # (batch, seq_len, input_size)
+        >>> h_0 = np.zeros((32, 256))
+        >>> W_xh = np.random.randn(128, 256)
+        >>> W_hh = np.random.randn(256, 256)
+        >>> b_h = np.zeros(256)
+        >>> outputs, hidden_states = rnn_forward(x, h_0, W_xh, W_hh, b_h)
+        >>> print(outputs.shape)  # (32, 10, 256)
+    """
+    batch_size, seq_len, input_size = x.shape
+    hidden_size = h_0.shape[1]
+    
+    # Initialize outputs
+    outputs = np.zeros((batch_size, seq_len, hidden_size))
+    hidden_states = np.zeros((batch_size, seq_len, hidden_size))
+    
+    h_t = h_0
+    
+    # Process sequence
+    for t in range(seq_len):
+        h_t = rnn_cell_forward(x[:, t, :], h_t, W_xh, W_hh, b_h)
+        outputs[:, t, :] = h_t
+        hidden_states[:, t, :] = h_t
+    
+    return outputs, hidden_states
+
+
+# ============================================================================
+# LSTM (LONG SHORT-TERM MEMORY)
+# ============================================================================
+
+def lstm_cell_forward(
+    x_t: np.ndarray,
+    h_prev: np.ndarray,
+    c_prev: np.ndarray,
+    W_f: np.ndarray,
+    W_i: np.ndarray,
+    W_c: np.ndarray,
+    W_o: np.ndarray,
+    b_f: np.ndarray,
+    b_i: np.ndarray,
+    b_c: np.ndarray,
+    b_o: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Single timestep of LSTM cell
+    
+    LSTM has three gates:
+    - Forget gate: decides what to forget from cell state
+    - Input gate: decides what new information to store
+    - Output gate: decides what to output
+    
+    Args:
+        x_t: Input at timestep t, shape (batch, input_size)
+        h_prev: Previous hidden state, shape (batch, hidden_size)
+        c_prev: Previous cell state, shape (batch, hidden_size)
+        W_f, W_i, W_c, W_o: Weight matrices for gates
+        b_f, b_i, b_c, b_o: Bias vectors for gates
+        
+    Returns:
+        Tuple of (h_t, c_t)
+        - h_t: New hidden state, shape (batch, hidden_size)
+        - c_t: New cell state, shape (batch, hidden_size)
+        
+    Example:
+        >>> x_t = np.random.randn(32, 128)
+        >>> h_prev = np.random.randn(32, 256)
+        >>> c_prev = np.random.randn(32, 256)
+        >>> # Initialize weights...
+        >>> h_t, c_t = lstm_cell_forward(x_t, h_prev, c_prev, W_f, W_i, W_c, W_o, b_f, b_i, b_c, b_o)
+        >>> print(h_t.shape, c_t.shape)  # (32, 256), (32, 256)
+    """
+    # Concatenate input and previous hidden state
+    concat = np.concatenate([h_prev, x_t], axis=1)
+    
+    # Forget gate
+    f_t = sigmoid(np.dot(concat, W_f) + b_f)
+    
+    # Input gate
+    i_t = sigmoid(np.dot(concat, W_i) + b_i)
+    
+    # Candidate cell state
+    c_tilde = np.tanh(np.dot(concat, W_c) + b_c)
+    
+    # New cell state
+    c_t = f_t * c_prev + i_t * c_tilde
+    
+    # Output gate
+    o_t = sigmoid(np.dot(concat, W_o) + b_o)
+    
+    # New hidden state
+    h_t = o_t * np.tanh(c_t)
+    
+    return h_t, c_t
+
+
+def lstm_forward(
+    x: np.ndarray,
+    h_0: np.ndarray,
+    c_0: np.ndarray,
+    W_f: np.ndarray,
+    W_i: np.ndarray,
+    W_c: np.ndarray,
+    W_o: np.ndarray,
+    b_f: np.ndarray,
+    b_i: np.ndarray,
+    b_c: np.ndarray,
+    b_o: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Forward pass through entire LSTM sequence
+    
+    Args:
+        x: Input sequence, shape (batch, seq_len, input_size)
+        h_0: Initial hidden state, shape (batch, hidden_size)
+        c_0: Initial cell state, shape (batch, hidden_size)
+        W_f, W_i, W_c, W_o: Weight matrices
+        b_f, b_i, b_c, b_o: Bias vectors
+        
+    Returns:
+        Tuple of (outputs, hidden_states, cell_states)
+        - outputs: shape (batch, seq_len, hidden_size)
+        - hidden_states: shape (batch, seq_len, hidden_size)
+        - cell_states: shape (batch, seq_len, hidden_size)
+        
+    Example:
+        >>> x = np.random.randn(32, 10, 128)
+        >>> h_0 = np.zeros((32, 256))
+        >>> c_0 = np.zeros((32, 256))
+        >>> # Initialize weights...
+        >>> outputs, h_states, c_states = lstm_forward(x, h_0, c_0, W_f, W_i, W_c, W_o, b_f, b_i, b_c, b_o)
+        >>> print(outputs.shape)  # (32, 10, 256)
+    """
+    batch_size, seq_len, input_size = x.shape
+    hidden_size = h_0.shape[1]
+    
+    # Initialize outputs
+    outputs = np.zeros((batch_size, seq_len, hidden_size))
+    hidden_states = np.zeros((batch_size, seq_len, hidden_size))
+    cell_states = np.zeros((batch_size, seq_len, hidden_size))
+    
+    h_t = h_0
+    c_t = c_0
+    
+    # Process sequence
+    for t in range(seq_len):
+        h_t, c_t = lstm_cell_forward(
+            x[:, t, :], h_t, c_t,
+            W_f, W_i, W_c, W_o,
+            b_f, b_i, b_c, b_o
+        )
+        outputs[:, t, :] = h_t
+        hidden_states[:, t, :] = h_t
+        cell_states[:, t, :] = c_t
+    
+    return outputs, hidden_states, cell_states
+
+
+# ============================================================================
+# GRU (GATED RECURRENT UNIT)
+# ============================================================================
+
+def gru_cell_forward(
+    x_t: np.ndarray,
+    h_prev: np.ndarray,
+    W_z: np.ndarray,
+    W_r: np.ndarray,
+    W_h: np.ndarray,
+    b_z: np.ndarray,
+    b_r: np.ndarray,
+    b_h: np.ndarray
+) -> np.ndarray:
+    """
+    Single timestep of GRU cell
+    
+    GRU has two gates:
+    - Update gate: decides how much to update
+    - Reset gate: decides how much to forget
+    
+    Args:
+        x_t: Input at timestep t, shape (batch, input_size)
+        h_prev: Previous hidden state, shape (batch, hidden_size)
+        W_z, W_r, W_h: Weight matrices for gates
+        b_z, b_r, b_h: Bias vectors for gates
+        
+    Returns:
+        h_t: New hidden state, shape (batch, hidden_size)
+        
+    Example:
+        >>> x_t = np.random.randn(32, 128)
+        >>> h_prev = np.random.randn(32, 256)
+        >>> # Initialize weights...
+        >>> h_t = gru_cell_forward(x_t, h_prev, W_z, W_r, W_h, b_z, b_r, b_h)
+        >>> print(h_t.shape)  # (32, 256)
+    """
+    # Concatenate input and previous hidden state
+    concat = np.concatenate([h_prev, x_t], axis=1)
+    
+    # Update gate
+    z_t = sigmoid(np.dot(concat, W_z) + b_z)
+    
+    # Reset gate
+    r_t = sigmoid(np.dot(concat, W_r) + b_r)
+    
+    # Candidate hidden state
+    concat_reset = np.concatenate([r_t * h_prev, x_t], axis=1)
+    h_tilde = np.tanh(np.dot(concat_reset, W_h) + b_h)
+    
+    # New hidden state
+    h_t = (1 - z_t) * h_prev + z_t * h_tilde
+    
+    return h_t
+
+
+def gru_forward(
+    x: np.ndarray,
+    h_0: np.ndarray,
+    W_z: np.ndarray,
+    W_r: np.ndarray,
+    W_h: np.ndarray,
+    b_z: np.ndarray,
+    b_r: np.ndarray,
+    b_h: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Forward pass through entire GRU sequence
+    
+    Args:
+        x: Input sequence, shape (batch, seq_len, input_size)
+        h_0: Initial hidden state, shape (batch, hidden_size)
+        W_z, W_r, W_h: Weight matrices
+        b_z, b_r, b_h: Bias vectors
+        
+    Returns:
+        Tuple of (outputs, hidden_states)
+        - outputs: shape (batch, seq_len, hidden_size)
+        - hidden_states: shape (batch, seq_len, hidden_size)
+        
+    Example:
+        >>> x = np.random.randn(32, 10, 128)
+        >>> h_0 = np.zeros((32, 256))
+        >>> # Initialize weights...
+        >>> outputs, hidden_states = gru_forward(x, h_0, W_z, W_r, W_h, b_z, b_r, b_h)
+        >>> print(outputs.shape)  # (32, 10, 256)
+    """
+    batch_size, seq_len, input_size = x.shape
+    hidden_size = h_0.shape[1]
+    
+    # Initialize outputs
+    outputs = np.zeros((batch_size, seq_len, hidden_size))
+    hidden_states = np.zeros((batch_size, seq_len, hidden_size))
+    
+    h_t = h_0
+    
+    # Process sequence
+    for t in range(seq_len):
+        h_t = gru_cell_forward(
+            x[:, t, :], h_t,
+            W_z, W_r, W_h,
+            b_z, b_r, b_h
+        )
+        outputs[:, t, :] = h_t
+        hidden_states[:, t, :] = h_t
+    
+    return outputs, hidden_states
+
+
+# ============================================================================
+# BIDIRECTIONAL RNN
+# ============================================================================
+
+def bidirectional_rnn_forward(
+    x: np.ndarray,
+    h_0_forward: np.ndarray,
+    h_0_backward: np.ndarray,
+    W_xh_f: np.ndarray,
+    W_hh_f: np.ndarray,
+    b_h_f: np.ndarray,
+    W_xh_b: np.ndarray,
+    W_hh_b: np.ndarray,
+    b_h_b: np.ndarray
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Bidirectional RNN forward pass
+    
+    Processes sequence in both forward and backward directions.
+    
+    Args:
+        x: Input sequence, shape (batch, seq_len, input_size)
+        h_0_forward: Initial forward hidden state
+        h_0_backward: Initial backward hidden state
+        W_xh_f, W_hh_f, b_h_f: Forward RNN parameters
+        W_xh_b, W_hh_b, b_h_b: Backward RNN parameters
+        
+    Returns:
+        Tuple of (outputs, forward_states, backward_states)
+        - outputs: Concatenated forward and backward, shape (batch, seq_len, 2*hidden_size)
+        
+    Example:
+        >>> x = np.random.randn(32, 10, 128)
+        >>> h_0_f = np.zeros((32, 256))
+        >>> h_0_b = np.zeros((32, 256))
+        >>> # Initialize weights...
+        >>> outputs, h_f, h_b = bidirectional_rnn_forward(x, h_0_f, h_0_b, W_xh_f, W_hh_f, b_h_f, W_xh_b, W_hh_b, b_h_b)
+        >>> print(outputs.shape)  # (32, 10, 512)
+    """
+    # Forward pass
+    forward_outputs, forward_states = rnn_forward(
+        x, h_0_forward, W_xh_f, W_hh_f, b_h_f
+    )
+    
+    # Backward pass (reverse sequence)
+    x_reversed = np.flip(x, axis=1)
+    backward_outputs, backward_states = rnn_forward(
+        x_reversed, h_0_backward, W_xh_b, W_hh_b, b_h_b
+    )
+    backward_outputs = np.flip(backward_outputs, axis=1)
+    backward_states = np.flip(backward_states, axis=1)
+    
+    # Concatenate forward and backward
+    outputs = np.concatenate([forward_outputs, backward_outputs], axis=2)
+    
+    return outputs, forward_states, backward_states
+
+
+# ============================================================================
+# UTILITY FUNCTIONS
+# ============================================================================
+
+def sigmoid(x: np.ndarray) -> np.ndarray:
+    """
+    Sigmoid activation function
+    
+    Args:
+        x: Input array
+        
+    Returns:
+        Sigmoid of input
+    """
+    return 1 / (1 + np.exp(-np.clip(x, -500, 500)))
+
+
+def initialize_rnn_weights(
+    input_size: int,
+    hidden_size: int,
+    cell_type: str = 'rnn'
+) -> dict:
+    """
+    Initialize RNN weights
+    
+    Args:
+        input_size: Size of input features
+        hidden_size: Size of hidden state
+        cell_type: Type of RNN cell ('rnn', 'lstm', 'gru')
+        
+    Returns:
+        Dictionary of initialized weights
+        
+    Example:
+        >>> weights = initialize_rnn_weights(128, 256, cell_type='lstm')
+        >>> print(weights.keys())
+    """
+    weights = {}
+    
+    if cell_type == 'rnn':
+        weights['W_xh'] = np.random.randn(input_size, hidden_size) * 0.01
+        weights['W_hh'] = np.random.randn(hidden_size, hidden_size) * 0.01
+        weights['b_h'] = np.zeros(hidden_size)
+        
+    elif cell_type == 'lstm':
+        concat_size = hidden_size + input_size
+        weights['W_f'] = np.random.randn(concat_size, hidden_size) * 0.01
+        weights['W_i'] = np.random.randn(concat_size, hidden_size) * 0.01
+        weights['W_c'] = np.random.randn(concat_size, hidden_size) * 0.01
+        weights['W_o'] = np.random.randn(concat_size, hidden_size) * 0.01
+        weights['b_f'] = np.zeros(hidden_size)
+        weights['b_i'] = np.zeros(hidden_size)
+        weights['b_c'] = np.zeros(hidden_size)
+        weights['b_o'] = np.zeros(hidden_size)
+        
+    elif cell_type == 'gru':
+        concat_size = hidden_size + input_size
+        weights['W_z'] = np.random.randn(concat_size, hidden_size) * 0.01
+        weights['W_r'] = np.random.randn(concat_size, hidden_size) * 0.01
+        weights['W_h'] = np.random.randn(concat_size, hidden_size) * 0.01
+        weights['b_z'] = np.zeros(hidden_size)
+        weights['b_r'] = np.zeros(hidden_size)
+        weights['b_h'] = np.zeros(hidden_size)
+    
+    return weights
+
+
+def clip_gradients(gradients: np.ndarray, max_norm: float = 5.0) -> np.ndarray:
+    """
+    Clip gradients to prevent exploding gradients
+    
+    Args:
+        gradients: Gradient array
+        max_norm: Maximum gradient norm
+        
+    Returns:
+        Clipped gradients
+        
+    Example:
+        >>> grads = np.random.randn(100, 100) * 10
+        >>> clipped = clip_gradients(grads, max_norm=5.0)
+        >>> print(np.linalg.norm(clipped))  # <= 5.0
+    """
+    norm = np.linalg.norm(gradients)
+    if norm > max_norm:
+        gradients = gradients * (max_norm / norm)
+    return gradients
+
+
+# Aliases for convenience
+vanilla_rnn = rnn_forward
+lstm = lstm_forward
+gru = gru_forward
+bidirectional_rnn = bidirectional_rnn_forward

{ilovetools-0.2.19 → ilovetools-0.2.20/ilovetools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ilovetools
-Version: 0.2.19
+Version: 0.2.20
 Summary: A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs
 Home-page: https://github.com/AliMehdi512/ilovetools
 Author: Ali Mehdi
@@ -11,7 +11,7 @@ Project-URL: Repository, https://github.com/AliMehdi512/ilovetools
 Project-URL: Issues, https://github.com/AliMehdi512/ilovetools/issues
 Project-URL: Bug Reports, https://github.com/AliMehdi512/ilovetools/issues
 Project-URL: Source, https://github.com/AliMehdi512/ilovetools
-Keywords: utilities,tools,ai,ml,data-processing,automation,cnn,convolutional-neural-networks,conv2d,pooling,computer-vision,image-processing
+Keywords: utilities,tools,ai,ml,data-processing,automation,rnn,lstm,gru,recurrent-neural-networks,sequence-modeling,nlp
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules

{ilovetools-0.2.19 → ilovetools-0.2.20}/ilovetools.egg-info/SOURCES.txt

@@ -49,6 +49,7 @@ ilovetools/ml/normalization.py
 ilovetools/ml/optimizers.py
 ilovetools/ml/pipeline.py
 ilovetools/ml/regularization.py
+ilovetools/ml/rnn.py
 ilovetools/ml/timeseries.py
 ilovetools/ml/tuning.py
 ilovetools/security/__init__.py
@@ -73,4 +74,5 @@ tests/test_loss_functions.py
 tests/test_neural_network.py
 tests/test_normalization.py
 tests/test_optimizers.py
-tests/test_regularization.py
+tests/test_regularization.py
+tests/test_rnn.py

{ilovetools-0.2.19 → ilovetools-0.2.20}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ilovetools"
-version = "0.2.19"
+version = "0.2.20"
 description = "A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -12,7 +12,7 @@ license = "MIT"
 authors = [
     {name = "Ali Mehdi", email = "ali.mehdi.dev579@gmail.com"}
 ]
-keywords = ["utilities", "tools", "ai", "ml", "data-processing", "automation", "cnn", "convolutional-neural-networks", "conv2d", "pooling", "computer-vision", "image-processing"]
+keywords = ["utilities", "tools", "ai", "ml", "data-processing", "automation", "rnn", "lstm", "gru", "recurrent-neural-networks", "sequence-modeling", "nlp"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",

{ilovetools-0.2.19 → ilovetools-0.2.20}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="ilovetools",
-    version="0.2.19",
+    version="0.2.20",
     author="Ali Mehdi",
     author_email="ali.mehdi.dev579@gmail.com",
     description="A comprehensive Python utility library with modular tools for AI/ML, data processing, and daily programming needs",
@@ -57,7 +57,7 @@ setup(
             "soundfile>=0.12.0",
         ],
     },
-    keywords="utilities, tools, ai, ml, data-processing, automation, python-library, neural-networks, cnn, convolutional-neural-networks, conv2d, pooling, computer-vision, image-processing",
+    keywords="utilities, tools, ai, ml, data-processing, automation, python-library, neural-networks, rnn, lstm, gru, recurrent-neural-networks, sequence-modeling, nlp",
     project_urls={
         "Bug Reports": "https://github.com/AliMehdi512/ilovetools/issues",
         "Source": "https://github.com/AliMehdi512/ilovetools",

ilovetools-0.2.20/tests/test_rnn.py

@@ -0,0 +1,419 @@
+"""
+Tests for RNN operations module
+"""
+
+import numpy as np
+import sys
+import os
+
+# Add parent directory to path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from ilovetools.ml.rnn import (
+    # Basic RNN
+    rnn_cell_forward,
+    rnn_forward,
+    # LSTM
+    lstm_cell_forward,
+    lstm_forward,
+    # GRU
+    gru_cell_forward,
+    gru_forward,
+    # Bidirectional
+    bidirectional_rnn_forward,
+    # Utilities
+    sigmoid,
+    initialize_rnn_weights,
+    clip_gradients,
+    # Aliases
+    vanilla_rnn,
+    lstm,
+    gru,
+    bidirectional_rnn,
+)
+
+
+def test_rnn_cell_forward():
+    """Test basic RNN cell forward pass"""
+    print("Testing rnn_cell_forward...")
+    
+    batch_size = 32
+    input_size = 128
+    hidden_size = 256
+    
+    x_t = np.random.randn(batch_size, input_size)
+    h_prev = np.random.randn(batch_size, hidden_size)
+    W_xh = np.random.randn(input_size, hidden_size) * 0.01
+    W_hh = np.random.randn(hidden_size, hidden_size) * 0.01
+    b_h = np.zeros(hidden_size)
+    
+    h_t = rnn_cell_forward(x_t, h_prev, W_xh, W_hh, b_h)
+    
+    assert h_t.shape == (batch_size, hidden_size), "Output shape incorrect"
+    assert np.all(np.abs(h_t) <= 1.0), "tanh output should be in [-1, 1]"
+    
+    print("✓ rnn_cell_forward passed")
+
+
+def test_rnn_forward():
+    """Test basic RNN forward pass"""
+    print("Testing rnn_forward...")
+    
+    batch_size = 32
+    seq_len = 10
+    input_size = 128
+    hidden_size = 256
+    
+    x = np.random.randn(batch_size, seq_len, input_size)
+    h_0 = np.zeros((batch_size, hidden_size))
+    W_xh = np.random.randn(input_size, hidden_size) * 0.01
+    W_hh = np.random.randn(hidden_size, hidden_size) * 0.01
+    b_h = np.zeros(hidden_size)
+    
+    outputs, hidden_states = rnn_forward(x, h_0, W_xh, W_hh, b_h)
+    
+    assert outputs.shape == (batch_size, seq_len, hidden_size), "Outputs shape incorrect"
+    assert hidden_states.shape == (batch_size, seq_len, hidden_size), "Hidden states shape incorrect"
+    
+    print("✓ rnn_forward passed")
+
+
+def test_lstm_cell_forward():
+    """Test LSTM cell forward pass"""
+    print("Testing lstm_cell_forward...")
+    
+    batch_size = 32
+    input_size = 128
+    hidden_size = 256
+    
+    x_t = np.random.randn(batch_size, input_size)
+    h_prev = np.random.randn(batch_size, hidden_size)
+    c_prev = np.random.randn(batch_size, hidden_size)
+    
+    # Initialize weights
+    concat_size = hidden_size + input_size
+    W_f = np.random.randn(concat_size, hidden_size) * 0.01
+    W_i = np.random.randn(concat_size, hidden_size) * 0.01
+    W_c = np.random.randn(concat_size, hidden_size) * 0.01
+    W_o = np.random.randn(concat_size, hidden_size) * 0.01
+    b_f = np.zeros(hidden_size)
+    b_i = np.zeros(hidden_size)
+    b_c = np.zeros(hidden_size)
+    b_o = np.zeros(hidden_size)
+    
+    h_t, c_t = lstm_cell_forward(x_t, h_prev, c_prev, W_f, W_i, W_c, W_o, b_f, b_i, b_c, b_o)
+    
+    assert h_t.shape == (batch_size, hidden_size), "Hidden state shape incorrect"
+    assert c_t.shape == (batch_size, hidden_size), "Cell state shape incorrect"
+    
+    print("✓ lstm_cell_forward passed")
+
+
+def test_lstm_forward():
+    """Test LSTM forward pass"""
+    print("Testing lstm_forward...")
+    
+    batch_size = 32
+    seq_len = 10
+    input_size = 128
+    hidden_size = 256
+    
+    x = np.random.randn(batch_size, seq_len, input_size)
+    h_0 = np.zeros((batch_size, hidden_size))
+    c_0 = np.zeros((batch_size, hidden_size))
+    
+    # Initialize weights
+    concat_size = hidden_size + input_size
+    W_f = np.random.randn(concat_size, hidden_size) * 0.01
+    W_i = np.random.randn(concat_size, hidden_size) * 0.01
+    W_c = np.random.randn(concat_size, hidden_size) * 0.01
+    W_o = np.random.randn(concat_size, hidden_size) * 0.01
+    b_f = np.zeros(hidden_size)
+    b_i = np.zeros(hidden_size)
+    b_c = np.zeros(hidden_size)
+    b_o = np.zeros(hidden_size)
+    
+    outputs, hidden_states, cell_states = lstm_forward(
+        x, h_0, c_0, W_f, W_i, W_c, W_o, b_f, b_i, b_c, b_o
+    )
+    
+    assert outputs.shape == (batch_size, seq_len, hidden_size), "Outputs shape incorrect"
+    assert hidden_states.shape == (batch_size, seq_len, hidden_size), "Hidden states shape incorrect"
+    assert cell_states.shape == (batch_size, seq_len, hidden_size), "Cell states shape incorrect"
+    
+    print("✓ lstm_forward passed")
+
+
+def test_gru_cell_forward():
+    """Test GRU cell forward pass"""
+    print("Testing gru_cell_forward...")
+    
+    batch_size = 32
+    input_size = 128
+    hidden_size = 256
+    
+    x_t = np.random.randn(batch_size, input_size)
+    h_prev = np.random.randn(batch_size, hidden_size)
+    
+    # Initialize weights
+    concat_size = hidden_size + input_size
+    W_z = np.random.randn(concat_size, hidden_size) * 0.01
+    W_r = np.random.randn(concat_size, hidden_size) * 0.01
+    W_h = np.random.randn(concat_size, hidden_size) * 0.01
+    b_z = np.zeros(hidden_size)
+    b_r = np.zeros(hidden_size)
+    b_h = np.zeros(hidden_size)
+    
+    h_t = gru_cell_forward(x_t, h_prev, W_z, W_r, W_h, b_z, b_r, b_h)
+    
+    assert h_t.shape == (batch_size, hidden_size), "Hidden state shape incorrect"
+    
+    print("✓ gru_cell_forward passed")
+
+
+def test_gru_forward():
+    """Test GRU forward pass"""
+    print("Testing gru_forward...")
+    
+    batch_size = 32
+    seq_len = 10
+    input_size = 128
+    hidden_size = 256
+    
+    x = np.random.randn(batch_size, seq_len, input_size)
+    h_0 = np.zeros((batch_size, hidden_size))
+    
+    # Initialize weights
+    concat_size = hidden_size + input_size
+    W_z = np.random.randn(concat_size, hidden_size) * 0.01
+    W_r = np.random.randn(concat_size, hidden_size) * 0.01
+    W_h = np.random.randn(concat_size, hidden_size) * 0.01
+    b_z = np.zeros(hidden_size)
+    b_r = np.zeros(hidden_size)
+    b_h = np.zeros(hidden_size)
+    
+    outputs, hidden_states = gru_forward(x, h_0, W_z, W_r, W_h, b_z, b_r, b_h)
+    
+    assert outputs.shape == (batch_size, seq_len, hidden_size), "Outputs shape incorrect"
+    assert hidden_states.shape == (batch_size, seq_len, hidden_size), "Hidden states shape incorrect"
+    
+    print("✓ gru_forward passed")
+
+
+def test_bidirectional_rnn_forward():
+    """Test bidirectional RNN forward pass"""
+    print("Testing bidirectional_rnn_forward...")
+    
+    batch_size = 32
+    seq_len = 10
+    input_size = 128
+    hidden_size = 256
+    
+    x = np.random.randn(batch_size, seq_len, input_size)
+    h_0_f = np.zeros((batch_size, hidden_size))
+    h_0_b = np.zeros((batch_size, hidden_size))
+    
+    # Initialize weights for forward and backward
+    W_xh_f = np.random.randn(input_size, hidden_size) * 0.01
+    W_hh_f = np.random.randn(hidden_size, hidden_size) * 0.01
+    b_h_f = np.zeros(hidden_size)
+    
+    W_xh_b = np.random.randn(input_size, hidden_size) * 0.01
+    W_hh_b = np.random.randn(hidden_size, hidden_size) * 0.01
+    b_h_b = np.zeros(hidden_size)
+    
+    outputs, forward_states, backward_states = bidirectional_rnn_forward(
+        x, h_0_f, h_0_b, W_xh_f, W_hh_f, b_h_f, W_xh_b, W_hh_b, b_h_b
+    )
+    
+    # Output should be concatenation of forward and backward (2 * hidden_size)
+    assert outputs.shape == (batch_size, seq_len, 2 * hidden_size), "Outputs shape incorrect"
+    assert forward_states.shape == (batch_size, seq_len, hidden_size), "Forward states shape incorrect"
+    assert backward_states.shape == (batch_size, seq_len, hidden_size), "Backward states shape incorrect"
+    
+    print("✓ bidirectional_rnn_forward passed")
+
+
+def test_sigmoid():
+    """Test sigmoid function"""
+    print("Testing sigmoid...")
+    
+    x = np.array([-1000, -1, 0, 1, 1000])
+    result = sigmoid(x)
+    
+    assert np.all(result >= 0) and np.all(result <= 1), "Sigmoid should be in [0, 1]"
+    assert np.isclose(result[2], 0.5), "Sigmoid(0) should be 0.5"
+    
+    print("✓ sigmoid passed")
+
+
+def test_initialize_rnn_weights():
+    """Test RNN weight initialization"""
+    print("Testing initialize_rnn_weights...")
+    
+    input_size = 128
+    hidden_size = 256
+    
+    # Test RNN weights
+    weights_rnn = initialize_rnn_weights(input_size, hidden_size, cell_type='rnn')
+    assert 'W_xh' in weights_rnn, "RNN weights should have W_xh"
+    assert 'W_hh' in weights_rnn, "RNN weights should have W_hh"
+    assert 'b_h' in weights_rnn, "RNN weights should have b_h"
+    
+    # Test LSTM weights
+    weights_lstm = initialize_rnn_weights(input_size, hidden_size, cell_type='lstm')
+    assert 'W_f' in weights_lstm, "LSTM weights should have W_f"
+    assert 'W_i' in weights_lstm, "LSTM weights should have W_i"
+    assert 'W_c' in weights_lstm, "LSTM weights should have W_c"
+    assert 'W_o' in weights_lstm, "LSTM weights should have W_o"
+    
+    # Test GRU weights
+    weights_gru = initialize_rnn_weights(input_size, hidden_size, cell_type='gru')
+    assert 'W_z' in weights_gru, "GRU weights should have W_z"
+    assert 'W_r' in weights_gru, "GRU weights should have W_r"
+    assert 'W_h' in weights_gru, "GRU weights should have W_h"
+    
+    print("✓ initialize_rnn_weights passed")
+
+
+def test_clip_gradients():
+    """Test gradient clipping"""
+    print("Testing clip_gradients...")
+    
+    # Create large gradients
+    grads = np.random.randn(100, 100) * 10
+    
+    # Clip to max norm 5.0
+    clipped = clip_gradients(grads, max_norm=5.0)
+    
+    norm = np.linalg.norm(clipped)
+    assert norm <= 5.0, "Clipped gradient norm should be <= max_norm"
+    
+    # Test with small gradients (should not clip)
+    small_grads = np.random.randn(10, 10) * 0.1
+    clipped_small = clip_gradients(small_grads, max_norm=5.0)
+    assert np.allclose(small_grads, clipped_small), "Small gradients should not be clipped"
+    
+    print("✓ clip_gradients passed")
+
+
+def test_aliases():
+    """Test function aliases"""
+    print("Testing aliases...")
+    
+    batch_size = 8
+    seq_len = 5
+    input_size = 64
+    hidden_size = 128
+    
+    x = np.random.randn(batch_size, seq_len, input_size)
+    h_0 = np.zeros((batch_size, hidden_size))
+    
+    # Test vanilla_rnn alias
+    W_xh = np.random.randn(input_size, hidden_size) * 0.01
+    W_hh = np.random.randn(hidden_size, hidden_size) * 0.01
+    b_h = np.zeros(hidden_size)
+    
+    out1, h1 = vanilla_rnn(x, h_0, W_xh, W_hh, b_h)
+    out2, h2 = rnn_forward(x, h_0, W_xh, W_hh, b_h)
+    assert np.allclose(out1, out2), "vanilla_rnn alias should work"
+    
+    print("✓ aliases passed")
+
+
+def test_rnn_sequence_processing():
+    """Test that RNN processes sequences correctly"""
+    print("Testing RNN sequence processing...")
+    
+    batch_size = 4
+    seq_len = 5
+    input_size = 32
+    hidden_size = 64
+    
+    x = np.random.randn(batch_size, seq_len, input_size)
+    h_0 = np.zeros((batch_size, hidden_size))
+    W_xh = np.random.randn(input_size, hidden_size) * 0.01
+    W_hh = np.random.randn(hidden_size, hidden_size) * 0.01
+    b_h = np.zeros(hidden_size)
+    
+    outputs, hidden_states = rnn_forward(x, h_0, W_xh, W_hh, b_h)
+    
+    # Check that each timestep depends on previous
+    # (outputs should be different at each timestep)
+    assert not np.allclose(outputs[:, 0, :], outputs[:, 1, :]), "Outputs should differ across timesteps"
+    
+    print("✓ RNN sequence processing passed")
+
+
+def test_lstm_gates():
+    """Test that LSTM gates work correctly"""
+    print("Testing LSTM gates...")
+    
+    batch_size = 4
+    input_size = 32
+    hidden_size = 64
+    
+    x_t = np.random.randn(batch_size, input_size)
+    h_prev = np.random.randn(batch_size, hidden_size)
+    c_prev = np.random.randn(batch_size, hidden_size)
+    
+    # Initialize weights
+    concat_size = hidden_size + input_size
+    W_f = np.random.randn(concat_size, hidden_size) * 0.01
+    W_i = np.random.randn(concat_size, hidden_size) * 0.01
+    W_c = np.random.randn(concat_size, hidden_size) * 0.01
+    W_o = np.random.randn(concat_size, hidden_size) * 0.01
+    b_f = np.zeros(hidden_size)
+    b_i = np.zeros(hidden_size)
+    b_c = np.zeros(hidden_size)
+    b_o = np.zeros(hidden_size)
+    
+    h_t, c_t = lstm_cell_forward(x_t, h_prev, c_prev, W_f, W_i, W_c, W_o, b_f, b_i, b_c, b_o)
+    
+    # Cell state should be updated
+    assert not np.allclose(c_t, c_prev), "Cell state should be updated"
+    
+    # Hidden state should be different from previous
+    assert not np.allclose(h_t, h_prev), "Hidden state should be updated"
+    
+    print("✓ LSTM gates passed")
+
+
+def run_all_tests():
+    """Run all tests"""
+    print("\n" + "="*60)
+    print("RNN OPERATIONS MODULE TESTS")
+    print("="*60 + "\n")
+    
+    # Basic RNN tests
+    test_rnn_cell_forward()
+    test_rnn_forward()
+    test_rnn_sequence_processing()
+    
+    # LSTM tests
+    test_lstm_cell_forward()
+    test_lstm_forward()
+    test_lstm_gates()
+    
+    # GRU tests
+    test_gru_cell_forward()
+    test_gru_forward()
+    
+    # Bidirectional tests
+    test_bidirectional_rnn_forward()
+    
+    # Utility tests
+    test_sigmoid()
+    test_initialize_rnn_weights()
+    test_clip_gradients()
+    
+    # Aliases
+    test_aliases()
+    
+    print("\n" + "="*60)
+    print("ALL TESTS PASSED! ✓")
+    print("="*60 + "\n")
+
+
+if __name__ == "__main__":
+    run_all_tests()