rxnn 0.1.83__py3-none-any.whl → 0.2.0__py3-none-any.whl

rxnn/transformers/sampler.py

@@ -1,15 +1,15 @@
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from typing import Iterator, Union
+from typing import Iterator, Union, Optional
 from transformers import PreTrainedTokenizerFast, PreTrainedTokenizer
 
 
 def sample(
         logits: torch.Tensor,
         temperature: float = 1.0,
-        top_k: int = None,
-        top_p: float = None,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
 ) -> torch.Tensor:
     if temperature <= 0:
         raise ValueError("Temperature must be > 0")
@@ -88,8 +88,8 @@ class Sampler:
             self,
             initial_tokens: torch.Tensor,
             temperature: float = 1.0,
-            top_k: int = None,
-            top_p: float = None,
+            top_k: Optional[int] = None,
+            top_p: Optional[float] = None,
             max_seq_len: int = 50,
             attention_mask: torch.Tensor = None,
             no_grad: bool = True,
@@ -120,10 +120,10 @@ class SampleDecoder:
         self.tokenizer = tokenizer
         self.device = self.sampler.device
 
-    def tokenize_input(self, text: str):
+    def tokenize_input(self, text: str, max_seq_len: int = 256):
         tokenized = self.tokenizer(
             text,
-            max_length=256,
+            max_length=max_seq_len,
             truncation=True,
             padding=False,
             return_tensors='pt',
@@ -135,7 +135,7 @@ class SampleDecoder:
         return tokenized
 
     def ids_iter(self, text: str, temperature: float = 0.1, top_p: float = 0.9, max_seq_len=256):
-        tokenized = self.tokenize_input(text)
+        tokenized = self.tokenize_input(text, max_seq_len=max_seq_len)
         return self.sampler(
             tokenized['input_ids'],
             temperature=temperature,
@@ -166,4 +166,278 @@ class SampleDecoder:
         if print_stream:
             return self.print_stream(text, temperature=temperature, top_p=top_p, max_seq_len=max_seq_len)
         else:
-            return self.txt(text, temperature=temperature, top_p=top_p, max_seq_len=max_seq_len)
+            return self.txt(text, temperature=temperature, top_p=top_p, max_seq_len=max_seq_len)
+
+class InteractionSampler(SampleDecoder):
+    def __init__(self, sampler: Sampler, tokenizer: Union[PreTrainedTokenizer, PreTrainedTokenizerFast]):
+        super(InteractionSampler, self).__init__(sampler, tokenizer)
+
+    def txt(self, text: str, temperature: float = 0.1, top_p: float = 0.9, max_seq_len: int = 256, special_token_spaces: bool = True):
+        txt = '[Q]' + text + '[A]'
+        start_txt = '[Q] ' + text + ' [A] ' if special_token_spaces else txt
+        return start_txt + ''.join(self.txt_iter(txt, temperature, top_p, max_seq_len))
+
+    def print_stream(self, text: str, temperature: float = 0.1, top_p: float = 0.9, max_seq_len: int = 256, special_token_spaces: bool = True):
+        txt = '[Q]' + text + '[A]'
+        start_txt = '[Q] ' + text + ' [A] ' if special_token_spaces else txt
+        print(start_txt, end='')
+        resp = start_txt
+        for txt_token in self.txt_iter(txt, temperature=temperature, top_p=top_p, max_seq_len=max_seq_len):
+            print(txt_token, end='')
+            resp += txt_token
+        return resp
+
+    def __call__(self, text: str, print_stream: bool = False, temperature: float = 0.1, top_p: float = 0.9,
+                 max_seq_len: int = 256, special_token_spaces: bool = True):
+        if print_stream:
+            return self.print_stream(text, temperature=temperature, top_p=top_p, max_seq_len=max_seq_len, special_token_spaces=special_token_spaces)
+        else:
+            return self.txt(text, temperature=temperature, top_p=top_p, max_seq_len=max_seq_len, special_token_spaces=special_token_spaces)
+
+
+def sample_batch(
+        logits: torch.Tensor,
+        temperature: float = 1.0,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Returns (sampled_tokens, log_probs)"""
+    if temperature <= 0:
+        raise ValueError("Temperature must be > 0")
+
+    # Store original dtype and device
+    original_dtype = logits.dtype
+    device = logits.device
+
+    # Convert to float32 for numerical stability
+    logits = logits.float()
+
+    # Apply temperature
+    logits = logits / temperature
+
+    # Apply top-k filtering
+    if top_k is not None and top_k > 0:
+        topk_values, _ = torch.topk(logits, top_k, dim=-1)
+        min_topk = topk_values[:, -1].unsqueeze(-1)
+        logits = torch.where(logits < min_topk, torch.tensor(-float('inf'), device=device), logits)
+
+    # Apply top-p filtering
+    if top_p is not None and 0 < top_p <= 1.0:
+        # Sort logits in descending order
+        sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+
+        # Calculate cumulative probabilities
+        sorted_probs = F.softmax(sorted_logits, dim=-1)
+        cumulative_probs = torch.cumsum(sorted_probs, dim=-1)
+
+        # Create mask to filter tokens
+        sorted_mask = cumulative_probs <= top_p
+        sorted_mask[..., 0] = True  # Ensure at least one token is kept
+
+        # Create mask for original indices
+        mask = torch.zeros_like(logits, dtype=torch.bool)
+        mask.scatter_(dim=-1, index=sorted_indices, src=sorted_mask)
+
+        # Apply mask
+        logits = torch.where(mask, logits, torch.tensor(-float('inf'), device=device))
+
+    # At this point ensure at least one token is available per batch element
+    alive = torch.isfinite(logits).any(dim=-1)
+    if not alive.all():
+        # Force keep the most probable token for dead rows
+        max_indices = logits.argmax(dim=-1)
+        logits[~alive] = -float('inf')
+        logits.scatter_(dim=-1, index=max_indices.unsqueeze(-1), value=0)
+
+    # Calculate log probabilities
+    log_probs = F.log_softmax(logits, dim=-1)
+
+    # Convert to probabilities
+    probs = torch.exp(log_probs)
+
+    # Ensure numerical stability for sampling
+    probs = probs.clamp(min=1e-12)
+
+    # Sample tokens
+    next_tokens = torch.multinomial(probs, num_samples=1).squeeze(-1)
+
+    # Gather log probabilities
+    selected_log_probs = log_probs.gather(-1, next_tokens.unsqueeze(-1)).squeeze(-1)
+
+    # Convert back to original dtype
+    return next_tokens.to(original_dtype), selected_log_probs.to(torch.float32)
+
+
+class BatchSampler:
+    def __init__(self, model: nn.Module, device: torch.device, end_token_id: int):
+        self.model = model.to(device)
+        self.device = device
+        self.end_token_id = end_token_id
+
+    def __call__(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor,
+        temperature: float = 1.0,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+        max_gen_len: int = 256,
+        no_grad: bool = True,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        batch_size, max_seq_len = input_ids.shape
+        initial_lens = attention_mask.sum(dim=1)
+        current_lens = initial_lens.clone()
+        finished = torch.zeros(batch_size, dtype=torch.bool, device=self.device)
+        log_probs = torch.zeros((batch_size, max_gen_len), dtype=torch.float32, device=self.device)
+        working_ids = input_ids.clone()
+        working_mask = attention_mask.clone()
+
+        for step in range(max_gen_len):
+            active = (~finished) & (current_lens < max_seq_len)
+            if not active.any():
+                break
+
+            active_indices = active.nonzero(as_tuple=True)[0]
+            active_current_lens = current_lens[active]
+            max_len = active_current_lens.max().item()
+
+            with torch.set_grad_enabled(not no_grad):
+                # Slice input and mask up to the current max length among active sequences
+                inputs = working_ids[active, :max_len]
+                masks = working_mask[active, :max_len]
+                logits = self.model(inputs, attention_mask=masks)
+
+            # Get the last valid token index for each active sequence
+            indices = (active_current_lens - 1).to(self.device)
+            last_logits = logits[torch.arange(len(active_indices), device=self.device), indices]
+
+            # Sample next tokens and log probs
+            next_tokens, step_log_probs = sample_batch(
+                last_logits, temperature=temperature, top_k=top_k, top_p=top_p
+            )
+
+            # Update working tensors
+            for i, idx in enumerate(active_indices):
+                if current_lens[idx] >= max_seq_len:
+                    continue
+                pos = current_lens[idx].item()
+                working_ids[idx, pos] = next_tokens[i]
+                working_mask[idx, pos] = 1
+                log_probs[idx, step] = step_log_probs[i]
+                current_lens[idx] += 1
+                if next_tokens[i] == self.end_token_id:
+                    finished[idx] = True
+
+        # Extract generated tokens
+        generated_ids = torch.zeros((batch_size, max_gen_len), dtype=torch.long, device=self.device)
+        generated_mask = torch.zeros((batch_size, max_gen_len), dtype=torch.bool, device=self.device)
+        for i in range(batch_size):
+            start = initial_lens[i].item()
+            end = current_lens[i].item()
+            gen_len = min(end - start, max_gen_len)
+            if gen_len > 0:
+                generated_ids[i, :gen_len] = working_ids[i, start:end]
+                generated_mask[i, :gen_len] = working_mask[i, start:end]
+
+        return generated_ids, generated_mask, log_probs
+
+
+class BatchSampleDecoder:
+    def __init__(
+            self,
+            sampler: BatchSampler,
+            tokenizer: Union[PreTrainedTokenizer, PreTrainedTokenizerFast],
+            bos_token: str = '[BOS]',
+            query_token: str = '[Q]',
+    ):
+        self.sampler = sampler
+        self.tokenizer = tokenizer
+        self.device = self.sampler.device
+        self.bos_token = bos_token
+        self.query_token = query_token
+
+    def tokenize_batch(self, texts: list[str], max_seq_len: int = 256):
+        tokenized = self.tokenizer(
+            [f'{self.bos_token}{self.query_token}{txt}' for txt in texts],
+            max_length=max_seq_len,
+            truncation=True,
+            padding='max_length',
+            return_tensors='pt',
+            return_attention_mask=True,
+            add_special_tokens=False
+        )
+        return {
+            'input_ids': tokenized['input_ids'].to(self.device),
+            'attention_mask': tokenized['attention_mask'].to(self.device)
+        }
+
+    def generate(
+            self,
+            texts: list[str],
+            temperature: float = 1.0,
+            top_p: Optional[float] = None,
+            top_k: Optional[int] = None,
+            max_seq_len: int = 256,
+            no_grad: bool = True,
+    ) -> list[str]:
+        tokenized = self.tokenize_batch(texts, max_seq_len)
+        generated_ids, _, _ = self.sampler(
+            input_ids=tokenized['input_ids'],
+            attention_mask=tokenized['attention_mask'],
+            temperature=temperature,
+            top_p=top_p,
+            top_k=top_k,
+            max_gen_len=max_seq_len,
+            no_grad=no_grad,
+        )
+
+        decoded = []
+        for seq in generated_ids:
+            # Trim after end token
+            end_pos = (seq == self.sampler.end_token_id).nonzero()
+            if end_pos.size(0) > 0:
+                seq = seq[:end_pos[0] + 1]
+            decoded.append(self.tokenizer.decode(seq).replace('Ċ', '\n').replace('Ġ', ' '))
+
+        return decoded
+
+    def generate_with_log_probs(
+            self,
+            texts: list[str],
+            temperature: float = 1.0,
+            top_p: Optional[float] = None,
+            top_k: Optional[int] = None,
+            max_seq_len: int = 256,
+            no_grad: bool = True,
+    ) -> tuple[list[str], torch.Tensor]:
+        tokenized = self.tokenize_batch(texts, max_seq_len)
+        generated_ids, _, log_probs = self.sampler(
+            input_ids=tokenized['input_ids'],
+            attention_mask=tokenized['attention_mask'],
+            temperature=temperature,
+            top_p=top_p,
+            top_k=top_k,
+            max_gen_len=max_seq_len,
+            no_grad=no_grad,
+        )
+
+        decoded = []
+        for i, seq in enumerate(generated_ids):
+            # Trim after end token
+            end_pos = (seq == self.sampler.end_token_id).nonzero()
+            if end_pos.size(0) > 0:
+                seq = seq[:end_pos[0] + 1]
+            decoded.append(self.tokenizer.decode(seq).replace('Ċ', '\n').replace('Ġ', ' '))
+
+        return decoded, log_probs
+
+    def __call__(
+            self,
+            texts: list[str],
+            temperature: float = 1.0,
+            top_p: Optional[float] = None,
+            top_k: Optional[int] = None,
+            max_seq_len: int = 256,
+            no_grad: bool = True,
+    ) -> list[str]:
+        return self.generate(texts, temperature, top_p, top_k, max_seq_len, no_grad)

{rxnn-0.1.83.dist-info → rxnn-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rxnn
-Version: 0.1.83
+Version: 0.2.0
 Summary: RxNN: Reactive Neural Networks Platform
 License: Apache-2.0
 Keywords: deep-learning,ai,machine-learning
@@ -23,8 +23,10 @@ Project-URL: Homepage, https://rxai.dev/rxnn
 Project-URL: Repository, https://github.com/RxAI-dev/rxnn/python
 Description-Content-Type: text/markdown
 
-<img src="https://raw.githubusercontent.com/RxAI-dev/RxNN/refs/heads/main/assets/logo/logo_rxai.webp" width="300" />
-<img src="https://raw.githubusercontent.com/RxAI-dev/RxNN/refs/heads/main/assets/logo/logo_rxnn.webp" width="300" />
+<span>
+  <img src="https://raw.githubusercontent.com/RxAI-dev/RxNN/refs/heads/main/assets/logo/logo_rxai_v2.png" width="400" />
+  <img src="https://raw.githubusercontent.com/RxAI-dev/RxNN/refs/heads/main/assets/logo/logo_rxnn_v2.png" width="400" />
+</span>
 
 # Reactive AI - RxNN
 ## Reactive Neural Networks Platform
@@ -61,8 +63,8 @@ We are working on three new reactive architectures, that progressively advance f
 
 Each new architecture is based on the previous one and adding new features/abilities. They will be progressively
 released with next versions of **RxNN** framework:
-- 0.1.x: Reactive Transformer base models, Base Model Learning (pre-training/fine-tuning) & Transformers extensions (MoE Attention, Short-Term Memory, etc.)
-- 0.2.x: Memory Reinforcement Learning (MRL) for Short-Term Memory & Reactive Transformer, Attention-based Memory System details
+- 0.1.x (Released): Reactive Transformer base models, Base Model Learning (pre-training/fine-tuning) & Transformers extensions (MoE Attention, Short-Term Memory, etc.)
+- 0.2.x (Released): Memory Reinforcement Learning (MRL) for Short-Term Memory & Reactive Transformer, Attention-based Memory System details
 - 0.3.x: Reinforcement Learning from Human Feedback for Reactive models (RxRLHF), basic Tensor Reactive
   Extensions (TRX/Rust) for full Reactive Transformer, RxT-Alpha release (+following models - RxT-Beta, etc.)
 - 0.4.x: Preactor base models, Tensor Database (TDB/Rust) for Long-Term Memory, mxRAG/revRAG subsystems
@@ -126,7 +128,7 @@ Submodules:
 - `rxnn.transformers.moe` - Mixture-of-Experts feed forward layers - `MoeFeedForward` & `GatedMoeFeedForward` (recommended)
 - `rxnn.transformer.layers` - complete reactive/classic transformer layers - `ReactiveTransformerLayer` & `ClassicTransformerLayer`
 - `rxnn.transformer.models` - reactive/classic transformer models - `ReactiveTransformerEncoder`, `ReactiveTransformerDecoder` & `ClassicTransformerEncoder`, `ClassicTransformerDecoder`
-- `rxnn.transformer.sampler` - samplers for reactive models (Sampler is the integral part of reactive architectures) - `Sampler` & `SampleDecoder`
+- `rxnn.transformer.sampler` - samplers for reactive models (Sampler is the integral part of reactive architectures) - `Sampler`, `SampleDecoder`, `BatchSampler` & `BatchSampleDecoder`
 
 In **RxNN** models are initialized in declarative style by class composition, but then they are wrapped in imperative classes,
 to be compatible with HuggingFace **JSON** config. In example:
@@ -211,7 +213,7 @@ include **Long-Term Memory**.
 
 The main `ShortTermMemory` class is located in `rxnn.memory.stm` module - the usage example is in Transformers module description.
 
-Other submodules are connected to **Memory Attention** and will be described in 0.2.x version, after MRL
+> 0.2.x Memory modules docs in progress - will be released soon
 
 #### Training
 Training module includes **Trainers** for different training stages of reactive models and shared training utils.
@@ -233,9 +235,9 @@ Submodules:
 - `rxnn.training.callbacks` contain Trainer callbacks, for different kind of utils (more info below)
 - `rxnn.training.scheduler` includes learning rate scheduler for training
 - `rxnn.training.bml` - Base Model Learning module with Trainers for pre-training and fine-tuning
-- `rxnn.training.mrl` - Memory Reinforcement Learning module with Trainers for MRL (from 0.2.x)
+- `rxnn.training.mrl` - Memory Reinforcement Learning module with Trainers for MRL
 - `rxnn.training.rxrlhf` - Reinforcement Learning from Human Feedback for Reactive Models module (from 0.3.x)
-- `rxnn.training.brl` - Behavioral Reinforcement Learning module (Reactor / from 0.7.x
+- `rxnn.training.brl` - Behavioral Reinforcement Learning module (Reactor / from 0.7.x)
 
 ##### Base Model Learning
 Docs in progress

rxnn-0.2.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+rxnn/.DS_Store,sha256=BxZLo9tFs48JMq6jhumiCnCPLTeCwl619CFSg4ClRAY,6148
+rxnn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rxnn/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rxnn/experimental/attention.py,sha256=46qwZLJuZMpIBrZ-r9DaQEPPmmZkO464C3Tkm_Mq-cs,23445
+rxnn/experimental/models.py,sha256=foBo0n0ufvBnfIdJomiEg3CuSOiWSt-q5ako7vzYxx4,4888
+rxnn/experimental/moe.py,sha256=jHZ1QhpWiVQOswVpFmuH7b2IUOPf0Uuf-I2Ddwsd7Us,6140
+rxnn/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rxnn/memory/attention.py,sha256=p-r8DK3iVhNn-JAESVzIXDCG8gk1R_-x5xHclZ5jgb0,1813
+rxnn/memory/norm.py,sha256=Ofl8Q5NYEF9GQeO0bhM43tkTW91J0y6TSvTAOYMgloM,6278
+rxnn/memory/stm.py,sha256=AoBgtmAKeAQ7U1OD3Zb2oObo27celvWyfJSUQjYw4Jc,4081
+rxnn/rxt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rxnn/rxt/models.py,sha256=zNrf6mn-s2vJyauHwNgYm_e-gFI1clmXp_JyCKGQD3E,12083
+rxnn/training/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rxnn/training/base.py,sha256=_xik1GXE4RJ_nxwqLQ1ccXA5pRtBCi-jL-jeRFBdHBU,11851
+rxnn/training/bml.py,sha256=FJszaQXOLx2ZHBa1CQpyMrG8i4Kj14E-gzDAEK_Ei5k,17272
+rxnn/training/callbacks.py,sha256=aqi8CfXUWnjMDbELYC5BPBbYyq0YiMicyVaTIr778DY,35053
+rxnn/training/dataset.py,sha256=XeRzo0KUYyQ43XjZ3o6Jban9ePIRtpHsqUmeKAQPRQk,50305
+rxnn/training/models.py,sha256=renPa5YH443XNTMFI-YTCwi5vNp3QzwF5UXedNd5hDk,5187
+rxnn/training/mrl.py,sha256=KcGvBWlBcFJ5GSwd4lx3pUXKlcyeNgJYPZAk3DRMH48,39179
+rxnn/training/reward.py,sha256=bjm8ya-HFIRA56JvQgnhtotKEpt8yw6yacVTV_SDpm4,5564
+rxnn/training/rl.py,sha256=FKrBOBAfNub_qzkceFQR-WUtCBffC6oGHE8wlPsz2YA,2682
+rxnn/training/scheduler.py,sha256=LcjU35mEwz2U5x3U6tLfeeYlBqMxbFSxYzJYuXkWbSY,1408
+rxnn/training/tokenizer.py,sha256=umaLByMBx_NMrQElA45HLm9gkuzyKWDTFaKVd-CjXl0,8344
+rxnn/training/utils.py,sha256=c-6aBaLnKeGfMW6Sp29z3FPLj5hdV3pyGJ2rZMcKs2s,5775
+rxnn/transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rxnn/transformers/attention.py,sha256=d0Igo1Nrn76BphbHrzekiKJfT3RCy4iSXSB6FLAOTgc,16247
+rxnn/transformers/ff.py,sha256=jJnuBDsnnX5uYC_WZH8cXAYrMnz0P-iX7MwcPivjRtI,2533
+rxnn/transformers/layers.py,sha256=MbOIX4PurbTbYxcXSavyFsNpTHCm26K_Ssk_VUCzKIE,7469
+rxnn/transformers/mask.py,sha256=J0cfLVLt3SzS2ra3KcY4khrkhI975Dw4CjpUi3Sn25s,419
+rxnn/transformers/models.py,sha256=VvP7r7E6tj7OWsYKlJLCy2vsQ3xSSnlNez6QxR-jBAA,8276
+rxnn/transformers/moe.py,sha256=j6jEx6Ip0zttlUZKKn82azxo95lkLZs-H2GLSMD88hY,5859
+rxnn/transformers/positional.py,sha256=1PjcJybUzeQlIKJI4tahAGZcYgCRCL0otxs7mpsNuzM,4410
+rxnn/transformers/sampler.py,sha256=2dpUQv88ekZa_CMSPLrXvB6X684wxUE2bDVznsi5ACs,17429
+rxnn/utils.py,sha256=ihb6OTyDtPiocB_lOvnq7eOkjjpCkgs8wxvXUBNQ7mM,996
+rxnn-0.2.0.dist-info/LICENSE,sha256=C8coDFIUYuOcke4JLPwTqahQUCyXyGq6WOaigOkx8tY,11275
+rxnn-0.2.0.dist-info/METADATA,sha256=EPKUh8u9f4ce4h9J4MO8wiLslO04Wd9VsSSlgrOqxUU,25959
+rxnn-0.2.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+rxnn-0.2.0.dist-info/RECORD,,

rxnn-0.1.83.dist-info/RECORD

@@ -1,31 +0,0 @@
-rxnn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rxnn/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rxnn/experimental/attention.py,sha256=bpZQiRXdQ8gJPwYRp3LBr2oELmrysB6-SWiD2F7UQrk,23127
-rxnn/experimental/models.py,sha256=foBo0n0ufvBnfIdJomiEg3CuSOiWSt-q5ako7vzYxx4,4888
-rxnn/experimental/moe.py,sha256=jHZ1QhpWiVQOswVpFmuH7b2IUOPf0Uuf-I2Ddwsd7Us,6140
-rxnn/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rxnn/memory/norm.py,sha256=Ofl8Q5NYEF9GQeO0bhM43tkTW91J0y6TSvTAOYMgloM,6278
-rxnn/memory/stm.py,sha256=EsD8slSP4_9dLuq6aFPDmuFe8PWilxh90so5Z3nm-ig,2057
-rxnn/rxt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rxnn/rxt/models.py,sha256=iUlSvdXrD1NVzZFmdC55qp4_3xoJj31FC40BGgYlf4Q,8763
-rxnn/training/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rxnn/training/base.py,sha256=_xik1GXE4RJ_nxwqLQ1ccXA5pRtBCi-jL-jeRFBdHBU,11851
-rxnn/training/bml.py,sha256=S1ZaXTybzeJH7uVFamCr4TPl2bLyZ5xmn_lSsjThTiM,19162
-rxnn/training/callbacks.py,sha256=xcU3W6_OsIEDTFTbN7S3uIWyGqLulbUWZMpW0aIXmF4,22699
-rxnn/training/dataset.py,sha256=XEDmOwD8v0c9u0QCk7I3xZShKaMtBDwYlfK1ofu6A1E,35789
-rxnn/training/scheduler.py,sha256=LcjU35mEwz2U5x3U6tLfeeYlBqMxbFSxYzJYuXkWbSY,1408
-rxnn/training/tokenizer.py,sha256=umaLByMBx_NMrQElA45HLm9gkuzyKWDTFaKVd-CjXl0,8344
-rxnn/transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rxnn/transformers/attention.py,sha256=dC0UmC-_kjX8US6Sf0Fi5zw5kJ-P6orH3JDHeBB5gI8,15695
-rxnn/transformers/ff.py,sha256=jJnuBDsnnX5uYC_WZH8cXAYrMnz0P-iX7MwcPivjRtI,2533
-rxnn/transformers/layers.py,sha256=OX8CsFY9A7uqH1SLwyexR_5BNlwheYrJHCGXjF8Q7HU,7186
-rxnn/transformers/mask.py,sha256=J0cfLVLt3SzS2ra3KcY4khrkhI975Dw4CjpUi3Sn25s,419
-rxnn/transformers/models.py,sha256=xbnn3FTNZFhaqq9A0XEM12ie_WL_58pPeq0qFXIgve0,7656
-rxnn/transformers/moe.py,sha256=j6jEx6Ip0zttlUZKKn82azxo95lkLZs-H2GLSMD88hY,5859
-rxnn/transformers/positional.py,sha256=ge-kaS6WnWnPGnWVp25ZK5bVkmhBUNCaELaN2rN_fSY,4097
-rxnn/transformers/sampler.py,sha256=poWBpxg1iuK5gEJtxHkk5VVfS9V48hs2Olqdhy_Gw8c,6548
-rxnn/utils.py,sha256=ihb6OTyDtPiocB_lOvnq7eOkjjpCkgs8wxvXUBNQ7mM,996
-rxnn-0.1.83.dist-info/LICENSE,sha256=C8coDFIUYuOcke4JLPwTqahQUCyXyGq6WOaigOkx8tY,11275
-rxnn-0.1.83.dist-info/METADATA,sha256=AhGTqWM9mvBzDRWliKeTRySDAL2cXXTYefRL_HGJN_Q,25930
-rxnn-0.1.83.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-rxnn-0.1.83.dist-info/RECORD,,