add rosaplus_cuda.py

rosaplus_cuda.py

@@ -0,0 +1,467 @@
+import torch
+import torch.nn.functional as F
+from typing import List, Optional, Dict, Tuple, Union
+import math
+import random
+from tqdm import tqdm
+from rosaplus import ROSAPlus, ROSAFallbackLM, ROSACharPredictor
+
+class ROSACudaWrapper:
+    """
+    CUDA-accelerated wrapper for ROSAPlus.
+    Optimized for batched inference using PyTorch.
+    """
+    def __init__(self, model: ROSAPlus, device: Union[str, torch.device] = "cuda"):
+        if model.lm is None:
+            raise RuntimeError("ROSAPlus model must have a built LM before converting to CUDA.")
+        
+        self.device = torch.device(device)
+        self.model = model
+        self.alphabet = model.lm.alphabet
+        self.char_to_idx = {ch: i for i, ch in enumerate(self.alphabet)}
+        self.idx_to_char = {i: ch for i, ch in enumerate(self.alphabet)}
+        self.vocab_size = len(self.alphabet)
+        
+        # --- Convert SAM Graph to Tensors ---
+        print(f"Converting SAM graph to CUDA tensors on {self.device}...")
+        
+        # 1. Suffix Links (c) and Max Length (d)
+        # Shape: [num_states]
+        self.c = torch.tensor(model.sam.c, dtype=torch.long, device=self.device)
+        self.d = torch.tensor(model.sam.d, dtype=torch.long, device=self.device)
+        
+        # 2. Transitions (b)
+        # We try to use a dense tensor [num_states, vocab_size] if memory permits.
+        # Otherwise, we might need a sparse approach (not implemented in this v1).
+        num_states = len(model.sam.b)
+        self.num_states = num_states
+        
+        print(f"Graph stats: {num_states} states, {self.vocab_size} vocab size.")
+        if num_states * self.vocab_size > 500_000_000: # heuristic limit (~2GB for int32)
+            print("WARNING: Graph is very large. Dense transition table might consume excessive GPU memory.")
+            
+        # Initialize with -1 (no transition)
+        self.transitions = torch.full((num_states, self.vocab_size), -1, dtype=torch.long, device=self.device)
+        
+        # Fill transitions
+        # This can be slow in Python, but it's a one-time cost.
+        # We construct it on CPU first then move to GPU.
+        b_cpu = torch.full((num_states, self.vocab_size), -1, dtype=torch.long)
+        for i, trans in enumerate(tqdm(model.sam.b, desc="Building transition table")):
+            for ch, next_state in trans.items():
+                if ch in self.char_to_idx:
+                    b_cpu[i, self.char_to_idx[ch]] = next_state
+        self.transitions = b_cpu.to(self.device)
+        
+        # 3. LM Counts (freq)
+        # We need N (total) and T (distinct) for Witten-Bell
+        # And the actual counts for probability distribution.
+        # counts_matrix: [num_states, vocab_size]
+        self.counts_matrix = torch.zeros((num_states, self.vocab_size), dtype=torch.float32, device="cpu")
+        
+        for i, freq in enumerate(tqdm(model.lm.freq, desc="Building count table")):
+            for ch, cnt in freq.items():
+                if ch in self.char_to_idx:
+                    self.counts_matrix[i, self.char_to_idx[ch]] = float(cnt)
+        
+        self.counts_matrix = self.counts_matrix.to(self.device)
+        
+        # Pre-compute N and T for Witten-Bell
+        self.N = self.counts_matrix.sum(dim=1) # [num_states]
+        self.T = (self.counts_matrix > 0).float().sum(dim=1) # [num_states]
+        
+        # Unigram counts for fallback
+        self.unigram_counts = torch.zeros(self.vocab_size, dtype=torch.float32, device=self.device)
+        for ch, cnt in model.lm.unigram.items():
+            if ch in self.char_to_idx:
+                self.unigram_counts[self.char_to_idx[ch]] = float(cnt)
+        self.unigram_total = self.unigram_counts.sum()
+
+        self.max_order = model.max_order
+        if self.max_order is None:
+            self.max_order = int(1e9)
+            
+        print("CUDA initialization complete.")
+
+    def _advance_batch(self, current_states: torch.Tensor, next_chars_idx: torch.Tensor) -> torch.Tensor:
+        """
+        Advance states for a batch of characters.
+        current_states: [batch_size]
+        next_chars_idx: [batch_size]
+        Returns: [batch_size] next states
+        """
+        # Look up transitions: transitions[state, char]
+        # Handle cases where transition doesn't exist (-1)
+        
+        # We need to handle the case where current_state is -1 (shouldn't happen in valid traversal but good to be safe)
+        # or where next_chars_idx is padding. Assuming valid inputs for now.
+        
+        next_states = self.transitions[current_states, next_chars_idx]
+        
+        # If transition is -1, it means we fall off the graph from that state with that char.
+        # In the original code:
+        # while v != -1 and ch not in b[v]: v = c[v]
+        # if v == -1: return b[0].get(ch, 0)
+        # else: return b[v][ch]
+        
+        # The simple lookup above is NOT sufficient because it doesn't follow suffix links on mismatch.
+        # We need to simulate the 'while' loop for mismatch handling.
+        # However, for *generation*, we usually sample from valid distributions, so the chosen char
+        # *should* have a transition if we sampled from the state's distribution?
+        # WAIT. The generated char might come from a fallback (shorter context).
+        # If we are at state S (context "ABC"), and we sample char 'X' which only exists in context "C" (parent of parent),
+        # then S does not have a transition for 'X'.
+        # We must follow suffix links to find the state that accepts 'X'.
+        
+        # Correct logic for updating state v with char c:
+        # v_new = transition(v, c)
+        # If transition(v, c) exists, great.
+        # If not, v = suffix_link(v), retry.
+        
+        # We can implement this "fallback search" in parallel.
+        active_mask = (next_states == -1)
+        curr = current_states.clone()
+        
+        # Limit iterations to avoid infinite loops (though DAG shouldn't loop)
+        max_depth = 100 # heuristic
+        
+        # Iterative fallback
+        for _ in range(max_depth):
+            if not active_mask.any():
+                break
+            
+            # For active ones, move to suffix link
+            curr[active_mask] = self.c[curr[active_mask]]
+            
+            # Check if we hit root's parent (-1)
+            root_parent_mask = (curr == -1) & active_mask
+            if root_parent_mask.any():
+                # If we fell off the root, we restart at root (0)
+                # And check if root has transition
+                # But wait, original code: if v == -1: return b[0].get(ch, 0)
+                # So effectively we try transition from 0.
+                
+                # We can handle this by setting curr to 0 for these, getting transition, and marking done.
+                # But let's follow the standard logic:
+                # If curr becomes -1, we try to transition from 0.
+                pass
+
+            # Try transition again for active ones
+            # If curr is -1, lookup fails. We need to handle -1 index carefully.
+            # We can use a temporary tensor filled with -1.
+            
+            valid_curr = curr.clone()
+            valid_curr[valid_curr == -1] = 0 # Safe lookup, result will be ignored if it was -1
+            
+            new_trans = self.transitions[valid_curr, next_chars_idx]
+            
+            # If curr was -1, the result is technically transition from 0?
+            # Original: if v == -1: return b[0].get(ch, 0)
+            # So if curr became -1, we take transition from 0.
+            # Let's handle the -1 case explicitly.
+            
+            # Update next_states where active
+            # If curr != -1: try transition. If exists (!= -1), update next_states and deactivate.
+            # If curr == -1: take transition from 0. Update next_states and deactivate.
+            
+            is_root_parent = (curr == -1)
+            
+            # Case 1: curr != -1
+            mask_normal = active_mask & (~is_root_parent)
+            if mask_normal.any():
+                t = self.transitions[curr[mask_normal], next_chars_idx[mask_normal]]
+                found = (t != -1)
+                
+                # Indices in the batch that found a match
+                found_indices = torch.nonzero(mask_normal).squeeze(1)[found]
+                next_states[found_indices] = t[found]
+                active_mask[found_indices] = False
+            
+            # Case 2: curr == -1
+            mask_root = active_mask & is_root_parent
+            if mask_root.any():
+                # transition from 0
+                t = self.transitions[torch.zeros_like(curr[mask_root]), next_chars_idx[mask_root]]
+                # If t is -1 (even root doesn't have it), then next state is 0.
+                t[t == -1] = 0 
+                
+                indices = torch.nonzero(mask_root).squeeze(1)
+                next_states[indices] = t
+                active_mask[indices] = False
+
+        # For any remaining active (shouldn't happen often), default to 0
+        next_states[active_mask] = 0
+        
+        return next_states
+
+    def get_probs_batch(self, current_states: torch.Tensor) -> torch.Tensor:
+        """
+        Compute Witten-Bell smoothed probabilities for a batch of states.
+        Returns: [batch_size, vocab_size]
+        """
+        batch_size = current_states.shape[0]
+        probs = torch.zeros((batch_size, self.vocab_size), device=self.device)
+        residual = torch.ones(batch_size, device=self.device) # The remaining probability mass
+        
+        curr = current_states.clone()
+        active_mask = torch.ones(batch_size, dtype=torch.bool, device=self.device)
+        
+        # We iterate up the suffix chain
+        # Ideally we loop until all active_mask is False
+        # But we can limit depth
+        max_depth = 100 
+        
+        for _ in range(max_depth):
+            if not active_mask.any():
+                break
+                
+            # Apply max_order constraint
+            # If d[curr] > max_order, skip this node (move to parent) without collecting counts
+            # But we must still move up.
+            
+            # Gather N and T for current states
+            # curr can be -1, handle safely
+            valid_mask = (curr != -1) & active_mask
+            if not valid_mask.any():
+                break
+                
+            # For valid states:
+            batch_indices = torch.nonzero(valid_mask).squeeze(1)
+            states_v = curr[batch_indices]
+            
+            # Check max_order
+            # If d[state] > max_order, we skip processing but set parent as next
+            d_v = self.d[states_v]
+            process_mask = (d_v <= self.max_order)
+            
+            # Indices to actually process (add counts)
+            proc_indices = batch_indices[process_mask]
+            proc_states = states_v[process_mask]
+            
+            if len(proc_states) > 0:
+                N_v = self.N[proc_states]
+                T_v = self.T[proc_states]
+                
+                # Witten-Bell Lambda
+                # lam = N / (N + T)
+                # If T=0, lam = 1.0 (fully trust this, though N must be 0 too then?)
+                # If N=0, skip
+                
+                has_counts = (N_v > 0)
+                
+                # Only update where N > 0
+                final_proc_indices = proc_indices[has_counts]
+                final_proc_states = proc_states[has_counts]
+                
+                if len(final_proc_states) > 0:
+                    N_f = N_v[has_counts]
+                    T_f = T_v[has_counts]
+                    
+                    lam = N_f / (N_f + T_f + 1e-9)
+                    # If T is 0, lam should be 1.0
+                    lam[T_f == 0] = 1.0
+                    
+                    # Update probs
+                    # probs += residual * lam * (counts / N)
+                    r = residual[final_proc_indices].unsqueeze(1) # [B, 1]
+                    l = lam.unsqueeze(1) # [B, 1]
+                    c = self.counts_matrix[final_proc_states] # [B, V]
+                    n = N_f.unsqueeze(1) # [B, 1]
+                    
+                    added_probs = r * l * (c / n)
+                    probs[final_proc_indices] += added_probs
+                    
+                    # Update residual
+                    residual[final_proc_indices] *= (1.0 - lam)
+
+            # Move to parent
+            curr[batch_indices] = self.c[states_v]
+            
+            # Update active mask (if curr becomes -1, stop for that item)
+            active_mask = active_mask & (curr != -1)
+            
+            # Optimization: if residual is very small, stop
+            active_mask = active_mask & (residual > 1e-6)
+
+        # Unigram fallback
+        # probs += residual * (unigram / total_unigram)
+        if self.unigram_total > 0:
+            uni_probs = self.unigram_counts / self.unigram_total
+            probs += residual.unsqueeze(1) * uni_probs.unsqueeze(0)
+        else:
+            # Uniform fallback
+            probs += residual.unsqueeze(1) * (1.0 / self.vocab_size)
+            
+        # Normalize (just in case)
+        sum_probs = probs.sum(dim=1, keepdim=True)
+        probs = probs / (sum_probs + 1e-12)
+        
+        return probs
+
+    def generate_batch(
+        self,
+        prompts: List[str],
+        steps: int = 100,
+        temperature: float = 1.0,
+        top_p: float = 0.9,
+        top_k: int = 50,
+        seed: Optional[int] = None
+    ) -> List[str]:
+        """
+        Batched generation.
+        """
+        if seed is not None:
+            torch.manual_seed(seed)
+            
+        batch_size = len(prompts)
+        
+        # Encode prompts
+        # We need to run the state machine for each prompt
+        # We can do this in parallel too, but lengths differ.
+        # Simple approach: Process one by one on CPU to get initial state, then batch.
+        # Or: Batch the prompt processing?
+        # Let's do batch prompt processing for speed.
+        
+        # Pad prompts to max length?
+        # Actually, we can just feed chars step by step.
+        
+        # 1. Initialize states to 0 (root)
+        current_states = torch.zeros(batch_size, dtype=torch.long, device=self.device)
+        
+        # 2. Feed prompts
+        # Find max length
+        max_len = max(len(p) for p in prompts)
+        
+        # Convert prompts to tensor [B, MaxLen], padded with some dummy (will be ignored by masking logic?)
+        # No, simpler: just iterate max_len times.
+        
+        print("Processing prompts...")
+        for i in range(max_len):
+            # Construct input char indices for this step
+            # If prompt is shorter, we just don't update state? 
+            # Or we keep feeding it?
+            # Actually, if prompt ended, we are ready.
+            # But we must reach the state corresponding to the FULL prompt.
+            
+            chars = []
+            mask = [] # True if this index has a char
+            for p in prompts:
+                if i < len(p):
+                    if p[i] in self.char_to_idx:
+                        chars.append(self.char_to_idx[p[i]])
+                    else:
+                        chars.append(0) # unknown char placeholder
+                    mask.append(True)
+                else:
+                    chars.append(0)
+                    mask.append(False)
+            
+            chars_tensor = torch.tensor(chars, dtype=torch.long, device=self.device)
+            mask_tensor = torch.tensor(mask, dtype=torch.bool, device=self.device)
+            
+            if mask_tensor.any():
+                # Only update states where mask is True
+                # We need a masked advance
+                active_states = current_states[mask_tensor]
+                active_chars = chars_tensor[mask_tensor]
+                new_states = self._advance_batch(active_states, active_chars)
+                current_states[mask_tensor] = new_states
+                
+        # 3. Generation Loop
+        print(f"Generating {steps} steps for {batch_size} sequences...")
+        generated_indices = []
+        
+        for _ in range(steps):
+            # Get probabilities
+            probs = self.get_probs_batch(current_states)
+            
+            # Sampling
+            # Apply Temperature
+            if temperature != 1.0:
+                probs = torch.pow(probs, 1.0 / temperature)
+                probs = probs / probs.sum(dim=1, keepdim=True)
+            
+            # Top-K
+            if top_k > 0:
+                vals, inds = torch.topk(probs, k=min(top_k, self.vocab_size), dim=1)
+                probs_topk = torch.zeros_like(probs)
+                probs_topk.scatter_(1, inds, vals)
+                probs = probs_topk / probs_topk.sum(dim=1, keepdim=True)
+                
+            # Top-P (Nucleus) - Simplified implementation
+            # Sorting is expensive. If top_k is small, maybe skipped.
+            # PyTorch doesn't have native vectorized top-p easily without sorting.
+            if top_p < 1.0:
+                sorted_probs, sorted_indices = torch.sort(probs, descending=True, dim=1)
+                cumulative_probs = torch.cumsum(sorted_probs, dim=1)
+                
+                # Remove tokens with cumulative probability above the threshold
+                sorted_indices_to_remove = cumulative_probs > top_p
+                # Shift the indices to the right to keep also the first token above the threshold
+                sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+                sorted_indices_to_remove[..., 0] = 0
+                
+                indices_to_remove = sorted_indices_to_remove.scatter(1, sorted_indices, sorted_indices_to_remove)
+                probs[indices_to_remove] = 0
+                probs = probs / probs.sum(dim=1, keepdim=True)
+                
+            # Sample
+            next_chars = torch.multinomial(probs, num_samples=1).squeeze(1)
+            
+            generated_indices.append(next_chars.cpu())
+            
+            # Advance state
+            current_states = self._advance_batch(current_states, next_chars)
+            
+        # 4. Decode
+        outputs = []
+        generated_indices = torch.stack(generated_indices, dim=1) # [B, Steps]
+        
+        for i in range(batch_size):
+            indices = generated_indices[i].tolist()
+            text = "".join([self.idx_to_char.get(idx, "") for idx in indices])
+            outputs.append(text)
+            
+        return outputs
+
+# Helper to easily use the CUDA wrapper
+def run_cuda_inference(model_path: str, prompts: List[str], steps=100, device="cuda"):
+    """
+    Load a model, convert to CUDA, and run batched inference.
+    """
+    print(f"Loading model from {model_path}...")
+    model = ROSAPlus.load(model_path)
+    
+    cuda_model = ROSACudaWrapper(model, device=device)
+    
+    results = cuda_model.generate_batch(prompts, steps=steps)
+    return results
+
+if __name__ == "__main__":
+
+    from rosaplus import ROSAPlus
+    # from rosaplus_cuda import run_cuda_inference, ROSACudaWrapper
+
+    # 1. 加载原有模型
+    model = ROSAPlus.load("your_model.bin")
+
+    # 2. 转换为 CUDA 加速版
+    cuda_model = ROSACudaWrapper(model, device="cuda")
+
+    # 3. 批量生成
+    prompts = ["The sky is", "Once upon a time", "Hello world"]
+    results = cuda_model.generate_batch(prompts, steps=200, temperature=0.8)
+
+    for p, r in zip(prompts, results):
+        print(f"{p} -> {r}")
+
+    # Example usage
+    import sys
+    if len(sys.argv) > 1:
+        model_file = sys.argv[1]
+        prompts = ["The meaning of life is", "Once upon a time"]
+        results = run_cuda_inference(model_file, prompts)
+        for p, r in zip(prompts, results):
+            print(f"Prompt: {p}")
+            print(f"Result: {r}")
+            print("-" * 20)