Datasets:

echodict
/

rosa-plus

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)

	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)