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("rosa-model.json") # 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)