markovgpu-rane 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

markovgpu/__init__.py

@@ -1,3 +1,5 @@
 from .backend import MarkovEngine
+from .sklearn import GpuHMM
 
-__all__ = ["MarkovEngine"]
+__all__ = ["MarkovEngine", "GpuHMM"]
+__version__ = "0.2.0"

markovgpu/backend.py

@@ -43,8 +43,11 @@ class MarkovEngine:
             if not os.path.exists(KERNEL_PATH):
                 raise FileNotFoundError(f"Kernel file missing at: {KERNEL_PATH}")
 
+            # OPTIMIZATION: Fast Math Build Options
+            build_options = "-cl-mad-enable -cl-fast-relaxed-math"
+
             with open(KERNEL_PATH, "r") as f:
-                self.prg = cl.Program(self.ctx, f.read()).build()
+                self.prg = cl.Program(self.ctx, f.read()).build(options=build_options)
 
             # 3. Cache Kernels (Robust Retrieval)
             self.use_gpu = True
@@ -80,24 +83,29 @@ class MarkovEngine:
             return v.dot(P)
 
         mf = cl.mem_flags
-        P = np.ascontiguousarray(P, dtype=np.float32)
+        # OPTIMIZATION: Transpose P for coalesced access
+        # The kernel expects P_T[id][k] which maps to P[k][id]
+        P_T = np.ascontiguousarray(P.T, dtype=np.float32)
         v = np.ascontiguousarray(v, dtype=np.float32)
         result = np.empty_like(v)
 
-        d_P = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=P)
+        d_P_T = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=P_T)
         d_v = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=v)
         d_res = cl.Buffer(self.ctx, mf.WRITE_ONLY, size=result.nbytes)
 
-        self.k_markov(self.queue, (N,), None, np.int32(N), d_v, d_P, d_res)
+        self.k_markov(self.queue, (N,), None, np.int32(N), d_v, d_P_T, d_res)
         cl.enqueue_copy(self.queue, result, d_res)
         return result
 
     def converge(self, P, start_v, tolerance=1e-5, max_steps=1000):
+        # Note: 'converge' currently uses the iterative step approach.
+        # For maximum optimization, this loop should ideally be moved to a kernel,
+        # but for now, we rely on the optimized 'step' logic implicitly or CPU fallback.
+        # Below is the robust hybrid implementation.
         N = len(start_v)
 
         # CPU Path
         if not self.use_gpu or N < GPU_THRESHOLD:
-            # print(f"🔄 Converging on CPU (N={N})...")
             current_v = start_v.copy()
             for i in range(max_steps):
                 new_v = current_v.dot(P)
@@ -107,21 +115,20 @@ class MarkovEngine:
             return current_v
 
         # GPU Path
-        # print(f"🔄 Converging on GPU (N={N})...")
+        # We reuse the specific buffers to avoid reallocation overhead in loop
         mf = cl.mem_flags
-        P = np.ascontiguousarray(P, dtype=np.float32)
+        P_T = np.ascontiguousarray(P.T, dtype=np.float32)
         start_v = np.ascontiguousarray(start_v, dtype=np.float32)
 
-        d_P = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=P)
-        d_v_read = cl.Buffer(
-            self.ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=start_v
-        )
+        d_P_T = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=P_T)
+        d_v_read = cl.Buffer(self.ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=start_v)
         d_v_write = cl.Buffer(self.ctx, mf.READ_WRITE, size=start_v.nbytes)
 
         current_v = start_v.copy()
 
         for i in range(max_steps):
-            self.k_markov(self.queue, (N,), None, np.int32(N), d_v_read, d_P, d_v_write)
+            # Use k_markov with Transposed Matrix
+            self.k_markov(self.queue, (N,), None, np.int32(N), d_v_read, d_P_T, d_v_write)
 
             if i % 10 == 0:
                 new_v = np.empty_like(current_v)
@@ -136,13 +143,6 @@ class MarkovEngine:
         return current_v
 
     # --- 2. Inference & Viterbi ---
-    def hmm_filter(self, transition_matrix, observation_probs):
-        """Standard HMM Filter (Returns Probabilities)"""
-        # Simplification: Running basic HMM forward pass
-        # For production use, usually prefer Log-Space to avoid underflow.
-        # This wrapper can be upgraded to use k_hmm_log if needed.
-        pass
-
     def decode_regime(self, transition_matrix, observation_probs):
         """Viterbi Algorithm (Finds Most Likely Path)"""
         T, N = observation_probs.shape
@@ -172,16 +172,15 @@ class MarkovEngine:
 
         # GPU Path
         mf = cl.mem_flags
+        # OPTIMIZATION: Transpose Log-Transition Matrix
         log_trans = np.log(transition_matrix + epsilon).astype(np.float32)
+        log_trans_T = np.ascontiguousarray(log_trans.T, dtype=np.float32)
+        
         log_emis = np.log(observation_probs + epsilon).astype(np.float32)
         log_delta = np.full(N, -np.log(N), dtype=np.float32)
 
-        d_trans = cl.Buffer(
-            self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=log_trans
-        )
-        d_delta_in = cl.Buffer(
-            self.ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=log_delta
-        )
+        d_trans_T = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=log_trans_T)
+        d_delta_in = cl.Buffer(self.ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=log_delta)
         d_delta_out = cl.Buffer(self.ctx, mf.READ_WRITE, size=log_delta.nbytes)
 
         full_backpointer_history = np.zeros((T, N), dtype=np.int32)
@@ -189,7 +188,7 @@ class MarkovEngine:
             self.ctx, mf.WRITE_ONLY, size=full_backpointer_history.nbytes // T
         )
 
-        print(f"🕵️ Decoding {T} days (GPU Accelerated)...")
+        print(f"🕵️ Decoding {T} days (GPU Optimized)...")
 
         for t in range(T):
             d_emis = cl.Buffer(
@@ -202,7 +201,7 @@ class MarkovEngine:
                 None,
                 np.int32(N),
                 d_delta_in,
-                d_trans,
+                d_trans_T, # Pass Transposed Matrix
                 d_emis,
                 d_delta_out,
                 d_backpointers,
@@ -231,96 +230,125 @@ class MarkovEngine:
         """Baum-Welch Expectation Maximization (Training)"""
         T = observations.shape[0]
         N = n_states
+        mf = cl.mem_flags
 
-        # Random Init
+        # 1. Initialize Params (Log Space)
         log_trans = np.log(
             np.full((N, N), 1.0 / N) + np.random.rand(N, N) * 0.01
         ).astype(np.float32)
         log_emis = np.log(observations + 1e-20).astype(np.float32)
 
-        mf = cl.mem_flags
-        d_trans = cl.Buffer(
-            self.ctx, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=log_trans
-        )
-        d_alpha = cl.Buffer(self.ctx, mf.READ_WRITE, size=T * N * 4)  # Full history
-        d_beta = cl.Buffer(self.ctx, mf.READ_WRITE, size=T * N * 4)  # Full history
-        d_emis = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=log_emis)
+        # 2. Allocate GPU Memory (VRAM)
+        # We need TWO transition buffers for optimization:
+        # A. Original (Row-Major) for Backward Pass & Accumulation
+        # B. Transposed (Col-Major) for Forward Pass
+        d_trans = cl.Buffer(self.ctx, mf.READ_WRITE, size=log_trans.nbytes)
+        d_trans_T = cl.Buffer(self.ctx, mf.READ_WRITE, size=log_trans.nbytes)
+        
+        # Initial Copy
+        cl.enqueue_copy(self.queue, d_trans, log_trans)
+        cl.enqueue_copy(self.queue, d_trans_T, np.ascontiguousarray(log_trans.T))
 
+        d_emis = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=log_emis)
+        
+        d_alpha = cl.Buffer(self.ctx, mf.READ_WRITE, size=T * N * 4) # float32 = 4 bytes
+        d_beta = cl.Buffer(self.ctx, mf.READ_WRITE, size=T * N * 4)
+        
         d_new_trans = cl.Buffer(self.ctx, mf.READ_WRITE, size=log_trans.nbytes)
         d_gamma_sums = cl.Buffer(self.ctx, mf.READ_WRITE, size=N * 4)
 
         prev_score = -np.inf
 
-        print(f"🧠 Training HMM ({N} States, {T} Steps)...")
+        print(f"🧠 Training HMM ({N} States, {T} Steps) on GPU...")
+
+        # Host buffers for initial checks and final readback
+        init_alpha = np.zeros(N, dtype=np.float32)
+        final_alpha_T = np.zeros(N, dtype=np.float32)
 
         for i in range(n_iters):
-            # 1. CPU Forward/Backward (Latency Optimized)
-            alpha_full, log_likelihood = self._cpu_forward(log_trans, log_emis)
-            beta_full = self._cpu_backward(log_trans, log_emis)
+            
+            # --- A. Forward Pass (GPU Loop) ---
+            # Uses Transposed Matrix (d_trans_T) for coalesced reads
+            init_alpha[:] = -np.log(N) + log_emis[0]
+            cl.enqueue_copy(self.queue, d_alpha, init_alpha, is_blocking=False)
 
-            # 2. GPU Accumulation (Throughput Optimized)
-            cl.enqueue_copy(self.queue, d_alpha, alpha_full)
-            cl.enqueue_copy(self.queue, d_beta, beta_full)
-            cl.enqueue_copy(self.queue, d_trans, log_trans)
+            for t in range(1, T):
+                prev_offset = (t - 1) * N
+                curr_offset = t * N
+                emis_offset = t * N
+                
+                self.k_hmm_log(
+                    self.queue, (N,), None,
+                    np.int32(N),
+                    d_alpha,            
+                    np.int32(prev_offset), 
+                    np.int32(curr_offset),
+                    d_trans_T, # <--- Optimized Read
+                    d_emis,             
+                    np.int32(emis_offset)
+                )
+
+            # --- B. Backward Pass (GPU Loop) ---
+            # Uses Original Matrix (d_trans) because Backward pass logic matches Row-Major
+            init_beta_end = np.zeros(N, dtype=np.float32) 
+            beta_end_offset = (T - 1) * N * 4 
+            cl.enqueue_copy(self.queue, d_beta, init_beta_end, dst_offset=beta_end_offset, is_blocking=False)
+
+            for t in range(T - 2, -1, -1):
+                curr_offset = t * N
+                future_offset = (t + 1) * N
+                future_emis_offset = (t + 1) * N
+
+                self.k_hmm_back(
+                    self.queue, (N,), None,
+                    np.int32(N),
+                    d_beta,            
+                    np.int32(future_offset),
+                    np.int32(curr_offset),
+                    d_trans, # <--- Optimized Read (Backward needs Row-Major)
+                    d_emis,
+                    np.int32(future_emis_offset)
+                )
+
+            # --- C. Accumulation (GPU) ---
+            self.queue.finish()
 
             self.k_acc_trans(
-                self.queue,
-                (N, N),
-                None,
-                np.int32(T),
-                np.int32(N),
-                d_alpha,
-                d_beta,
-                d_emis,
-                d_trans,
-                d_new_trans,
+                self.queue, (N, N), None,
+                np.int32(T), np.int32(N),
+                d_alpha, d_beta, d_emis, d_trans, d_new_trans
             )
 
             self.k_acc_gamma(
-                self.queue,
-                (N,),
-                None,
-                np.int32(T),
-                np.int32(N),
-                d_alpha,
-                d_beta,
-                d_gamma_sums,
+                self.queue, (N,), None,
+                np.int32(T), np.int32(N),
+                d_alpha, d_beta, d_gamma_sums
             )
 
-            # 3. Update
+            # --- D. Update & Check Convergence (CPU) ---
             new_log_trans_counts = np.empty_like(log_trans)
             log_gamma_sums = np.empty(N, dtype=np.float32)
 
             cl.enqueue_copy(self.queue, new_log_trans_counts, d_new_trans)
             cl.enqueue_copy(self.queue, log_gamma_sums, d_gamma_sums)
+            
+            # Calc Likelihood
+            alpha_T_offset = (T - 1) * N * 4
+            cl.enqueue_copy(self.queue, final_alpha_T, d_alpha, src_offset=alpha_T_offset)
+            log_likelihood = np.logaddexp.reduce(final_alpha_T)
 
+            # M-Step: Normalize
             log_trans = new_log_trans_counts - log_gamma_sums[:, None]
+            
+            # Update BOTH GPU Buffers for next iteration
+            cl.enqueue_copy(self.queue, d_trans, log_trans)
+            cl.enqueue_copy(self.queue, d_trans_T, np.ascontiguousarray(log_trans.T))
 
             change = log_likelihood - prev_score
-            print(
-                f"   Iter {i + 1}: Likelihood {log_likelihood:.2f} (Delta: {change:.4f})"
-            )
+            print(f"   Iter {i + 1}: Likelihood {log_likelihood:.2f} (Delta: {change:.4f})")
+            
             if abs(change) < tolerance:
                 break
             prev_score = log_likelihood
 
-        return np.exp(log_trans)
-
-    def _cpu_forward(self, log_trans, log_emis):
-        T, N = log_emis.shape
-        alpha = np.zeros((T, N), dtype=np.float32)
-        alpha[0] = -np.log(N) + log_emis[0]
-        for t in range(1, T):
-            for j in range(N):
-                prev = alpha[t - 1] + log_trans[:, j]
-                alpha[t, j] = np.logaddexp.reduce(prev) + log_emis[t, j]
-        return alpha, np.logaddexp.reduce(alpha[-1])
-
-    def _cpu_backward(self, log_trans, log_emis):
-        T, N = log_emis.shape
-        beta = np.zeros((T, N), dtype=np.float32)
-        for t in range(T - 2, -1, -1):
-            for i in range(N):
-                terms = log_trans[i, :] + log_emis[t + 1] + beta[t + 1]
-                beta[t, i] = np.logaddexp.reduce(terms)
-        return beta
+        return np.exp(log_trans)

markovgpu/kernels.cl

@@ -1,146 +1,164 @@
-// kernels.cl - The Complete Suite
+// kernels.cl - Memory Optimized (Transposed Access) + Fixed Write Permissions
 
 // --- HELPER: Log-Sum-Exp Trick ---
-// Prevents overflow when adding log-probabilities
 float log_add(float log_a, float log_b) {
     float max_val = max(log_a, log_b);
     float min_val = min(log_a, log_b);
     return max_val + log1p(exp(min_val - max_val));
 }
 
-// --- SECTION 1: Basic Markov Operations ---
+// --- SECTION 1: Basic Operations ---
 
-// 1. Standard Markov Step: Next = Current * Matrix
 __kernel void markov_step(
     const int N,
     __global const float *current_state,
-    __global const float *transition_mat,
+    __global const float *trans_mat_T, // EXPECTS TRANSPOSED MATRIX
     __global float *next_state)
 {
-    int id = get_global_id(0);
+    int id = get_global_id(0); // Target State (Row in Transposed Mat)
     if (id < N) {
         float sum = 0.0f;
+        int row_start = id * N; // Coalesced Start (Optimization)
+        
         for (int k = 0; k < N; k++) {
-            sum += current_state[k] * transition_mat[k * N + id];
+            // Read sequentially: P_T[id][k] corresponds to P[k][id]
+            sum += current_state[k] * trans_mat_T[row_start + k];
         }
         next_state[id] = sum;
     }
 }
 
-// 2. Standard HMM Filter (Probability Space)
-// Used for simple "What state am I in?" queries without log-space
 __kernel void hmm_forward_step(
     const int N,
     __global const float *alpha_prev,
-    __global const float *trans_mat,
+    __global const float *trans_mat_T, // EXPECTS TRANSPOSED MATRIX
     __global const float *emissions,
     __global float *alpha_new)
 {
     int id = get_global_id(0);
     if (id < N) {
         float sum = 0.0f;
+        int row_start = id * N; 
+
         for (int k = 0; k < N; k++) {
-            sum += alpha_prev[k] * trans_mat[k * N + id];
+            sum += alpha_prev[k] * trans_mat_T[row_start + k];
         }
         alpha_new[id] = sum * emissions[id];
     }
 }
 
-// --- SECTION 2: Advanced Log-Space Operations (Stable) ---
+// --- SECTION 2: Advanced Log-Space Operations ---
 
-// 3. Log-Space Forward (For Viterbi & Training)
+// 3. Log-Space Forward (Memory Optimized)
 __kernel void hmm_forward_log(
     const int N,
-    __global const float *log_alpha_prev, 
-    __global const float *log_trans_mat,  
-    __global const float *log_emissions,  
-    __global float *log_alpha_new)        
+    __global float *log_alpha_full,        // NO CONST (Write Permission Fix Preserved)
+    const int prev_offset,
+    const int curr_offset,
+    __global const float *log_trans_mat_T, // EXPECTS TRANSPOSED MATRIX
+    __global const float *log_emissions,
+    const int emis_offset)
 {
-    int id = get_global_id(0);
+    int id = get_global_id(0); // Target State (Row in Transposed Mat)
     if (id < N) {
         float log_sum = -INFINITY;
+        int row_start = id * N; 
+        
+        // Loop 'k' (Previous State). 
+        // In Transposed Matrix, 'id' is the Row, 'k' is the Column.
+        // So we read P_T[id][k] which corresponds to P[k][id]
         for (int k = 0; k < N; k++) {
-            float val = log_alpha_prev[k] + log_trans_mat[k * N + id];
+            float val = log_alpha_full[prev_offset + k] + log_trans_mat_T[row_start + k];
             if (k == 0) log_sum = val;
             else log_sum = log_add(log_sum, val);
         }
-        log_alpha_new[id] = log_sum + log_emissions[id];
+        
+        // Write to 'curr_offset'
+        log_alpha_full[curr_offset + id] = log_sum + log_emissions[emis_offset + id];
     }
 }
 
-// 4. Log-Space Backward (For Training)
+// 4. Log-Space Backward (Memory Optimized - Uses ORIGINAL Matrix)
+// Note: Backward pass needs P[i][j], which is naturally Row-Major.
+// So we DO NOT use the Transposed matrix here. It is already optimized!
 __kernel void hmm_backward_log(
-    const int N, 
-    __global const float *beta_future, 
-    __global const float *trans, 
-    __global const float *emis_future, 
-    __global float *beta_curr) 
+    const int N,
+    __global float *beta_full,            
+    const int future_offset,              
+    const int curr_offset,                
+    __global const float *trans, // ORIGINAL MATRIX (Row-Major)
+    __global const float *emis_full,      
+    const int future_emis_offset)         
 {
     int id = get_global_id(0); // State 'i'
     if (id < N) {
         float log_sum = -INFINITY;
+        int row_start = id * N;
+
         for (int j=0; j<N; j++) {
-            // transition i->j + emission(t+1) + beta(t+1)
-            float val = trans[id*N + j] + emis_future[j] + beta_future[j];
+            // Read sequentially: trans[row_start + j]
+            float val = trans[row_start + j] + 
+                        emis_full[future_emis_offset + j] + 
+                        beta_full[future_offset + j];
+            
             if (j==0) log_sum = val;
             else log_sum = log_add(log_sum, val);
         }
-        beta_curr[id] = log_sum;
+        beta_full[curr_offset + id] = log_sum;
     }
 }
 
-// 5. Viterbi Algorithm (Finds best path)
+// 5. Viterbi Algorithm (Memory Optimized)
 __kernel void viterbi_step(
     const int N,
     __global const float *log_delta_prev,
-    __global const float *log_trans_mat,
+    __global const float *log_trans_mat_T, // EXPECTS TRANSPOSED MATRIX
     __global const float *log_emissions,
-    __global float *log_delta_new,       
-    __global int *backpointers)          
+    __global float *log_delta_new,
+    __global int *backpointers)
 {
     int id = get_global_id(0);
     if (id < N) {
         float max_prob = -INFINITY;
         int best_prev_state = 0;
+        int row_start = id * N;
 
         for (int k = 0; k < N; k++) {
-            float prob = log_delta_prev[k] + log_trans_mat[k * N + id];
+            // Read sequentially: P_T[id][k]
+            float prob = log_delta_prev[k] + log_trans_mat_T[row_start + k];
             if (prob > max_prob) {
                 max_prob = prob;
                 best_prev_state = k;
             }
         }
         log_delta_new[id] = max_prob + log_emissions[id];
-        backpointers[id] = best_prev_state; 
+        backpointers[id] = best_prev_state;
     }
 }
 
-// --- SECTION 3: Learning Accumulators (Baum-Welch) ---
+// --- SECTION 3: Learning Accumulators (Unchanged) ---
 
 // 6. Accumulate Transitions (E-Step)
-// Condenses time T into N*N summary matrix
 __kernel void accumulate_transitions(
     const int T, const int N,
     __global const float *alpha_full, 
     __global const float *beta_full,  
     __global const float *emis_full,  
-    __global const float *trans_mat,  
+    __global const float *trans_mat, // Original Matrix
     __global float *new_trans_counts) 
 {
-    int row = get_global_id(1); // From State i
-    int col = get_global_id(0); // To State j
+    int row = get_global_id(1); 
+    int col = get_global_id(0); 
 
     if (row < N && col < N) {
         float log_sum_xi = -INFINITY;
         float log_trans_val = trans_mat[row * N + col];
 
-        // Loop over time 0 to T-2
         for (int t = 0; t < T - 1; t++) {
             float log_xi = alpha_full[t*N + row] + 
                            log_trans_val + 
                            emis_full[(t+1)*N + col] + 
                            beta_full[(t+1)*N + col];
-            
             if (t == 0) log_sum_xi = log_xi;
             else log_sum_xi = log_add(log_sum_xi, log_xi);
         }
@@ -149,7 +167,6 @@ __kernel void accumulate_transitions(
 }
 
 // 7. Accumulate Gammas (E-Step)
-// Condenses time T into N summary counts
 __kernel void accumulate_gammas(
     const int T, const int N,
     __global const float *alpha_full,

markovgpu/sklearn.py

@@ -0,0 +1,94 @@
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.utils.validation import check_array, check_is_fitted
+from scipy.stats import norm
+from .backend import MarkovEngine
+
+class GpuHMM(BaseEstimator, TransformerMixin):
+    """
+    Scikit-Learn compatible Wrapper for MarkovGPU.
+    Allows use in Pipelines, GridSearchCV, and Cross-Validation.
+    """
+    def __init__(self, n_states=2, n_iter=100, tolerance=1e-4, verbose=False):
+        self.n_states = n_states
+        self.n_iter = n_iter
+        self.tolerance = tolerance
+        self.verbose = verbose
+        self.engine = MarkovEngine()
+        
+        # Learned Parameters
+        self.trans_mat_ = None
+        self.start_prob_ = None
+    
+    def fit(self, X, y=None):
+        """
+        Trains the HMM on the GPU.
+        X: array-like of shape (n_samples, n_features) OR (n_samples,)
+           For now, we assume X represents 'Observation Probabilities' 
+           OR raw data we can model as Gaussian emissions.
+        """
+        # 1. Input Validation
+        X = check_array(X, ensure_2d=False)
+        
+        # 2. Heuristic: If X is 1D (Raw Data), we convert to Emission Probs
+        # using a simple Gaussian mixture assumption for convenience.
+        if X.ndim == 1 or X.shape[1] == 1:
+            if self.verbose:
+                print(f"ℹ️ Auto-converting raw data to {self.n_states} Gaussian states.")
+            X_flat = X.ravel()
+            obs_probs = self._auto_gaussian_emissions(X_flat)
+        else:
+            # Assume X is already [Probability of State 0, Prob of State 1, ...]
+            if X.shape[1] != self.n_states:
+                raise ValueError(f"Input has {X.shape[1]} columns, but n_states={self.n_states}. "
+                                 "If passing raw probabilities, cols must match n_states.")
+            obs_probs = X
+
+        # 3. Train on GPU
+        if self.verbose:
+            print(f"🚀 Offloading to GPU: {X.shape[0]} samples, {self.n_states} states")
+            
+        self.trans_mat_ = self.engine.fit(
+            obs_probs, 
+            n_states=self.n_states, 
+            n_iters=self.n_iter, 
+            tolerance=self.tolerance
+        )
+        
+        # Set is_fitted flag
+        self.is_fitted_ = True
+        return self
+
+    def predict(self, X):
+        """
+        Returns the most likely hidden state path (Viterbi).
+        """
+        check_is_fitted(self, ['trans_mat_'])
+        X = check_array(X, ensure_2d=False)
+        
+        if X.ndim == 1 or X.shape[1] == 1:
+            obs_probs = self._auto_gaussian_emissions(X.ravel())
+        else:
+            obs_probs = X
+            
+        return self.engine.decode_regime(self.trans_mat_, obs_probs)
+
+    def _auto_gaussian_emissions(self, data):
+        """
+        Helper: Splits data into N quantiles and assumes Gaussian emissions.
+        This makes the class 'Just Work' for simple 1D data.
+        """
+        T = len(data)
+        N = self.n_states
+        
+        # Smart Init: Sort data and split into N chunks to guess means
+        sorted_data = np.sort(data)
+        chunk_size = T // N
+        means = [np.mean(sorted_data[i*chunk_size : (i+1)*chunk_size]) for i in range(N)]
+        std = np.std(data) * 0.5 # Heuristic width
+        
+        probs = np.zeros((T, N), dtype=np.float32)
+        for k in range(N):
+            probs[:, k] = norm.pdf(data, loc=means[k], scale=std)
+            
+        return probs

markovgpu_rane-0.3.0.dist-info/METADATA

@@ -0,0 +1,205 @@
+Metadata-Version: 2.4
+Name: markovgpu-rane
+Version: 0.3.0
+Summary: High-performance Markov Chains & HMMs using OpenCL
+Author-email: Sahil Rane <sahilrane249@gmail.com>
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.12
+Requires-Dist: matplotlib>=3.8.0
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: pyopencl>=2024.1
+Requires-Dist: scikit-learn>=1.8.0
+Requires-Dist: scipy>=1.11.0
+Requires-Dist: yfinance>=1.1.0
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# ⚡ **MarkovGPU**
+
+### *Massive Scale Markov Models on Consumer Hardware*
+<img width="1024" height="338" alt="image" src="https://github.com/user-attachments/assets/b57dab80-ba03-4d1d-bb4d-6390e3f63f52" />
+
+> **Run million-state HMMs on your laptop GPU.**  
+> **No CUDA required • Hybrid CPU/GPU Backend • Production Ready**
+
+[![PyPI version](https://img.shields.io/pypi/v/markovgpu-rane?style=flat-square&color=blue)](https://pypi.org/project/markovgpu-rane/)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg?style=flat-square)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/wizardwithcodehazard/markov/test.yml?style=flat-square&label=CI)](https://github.com/wizardwithcodehazard/markov/actions)
+
+</div>
+
+---
+
+## 🌟 **The Engine for Stochastic Intelligence**
+
+**MarkovGPU** is a high-performance probabilistic modeling library built for speed. It breaks the "NVIDIA Monopoly" by using **OpenCL** to accelerate **Hidden Markov Models (HMM)** and **Markov Chains** on *any* GPU—including AMD Radeon, Intel Arc, and Apple Silicon.
+
+It doesn't just run; it *thinks*. The **Smart Hybrid Backend** automatically routes small tasks to the CPU (NumPy) and massive workloads to the GPU, giving you optimal performance at every scale.
+
+---
+
+## 🚀 **Core Superpowers**
+
+| Feature | Magic Behind It |
+|-------|----------------|
+| ⚡ **Hardware Agnostic** | Built on **OpenCL** — runs on AMD, Intel, NVIDIA, and Apple M1/M2/M3 chips. |
+| 🧠 **Smart Hybrid Backend** | Auto-detects problem size ($N$). Uses **NumPy** for speed on small data, **GPU** for massive throughput. |
+| 📉 **Log-Space Stability** | Implements **Log-Sum-Exp** kernels to prevent underflow on long time-series (1M+ steps). |
+| 🕵️ **Viterbi Decoding** | Finds the "Hidden Truth" in noisy data (e.g., market regimes, DNA sequences) in milliseconds. |
+| 🎓 **Unsupervised Learning** | **Baum-Welch (EM)** algorithm trains models directly on the GPU, learning rules from raw data. |
+| 📦 **Zero-Config Install** | `pip install markovgpu-rane`. No driver hell. No CUDA toolkit nightmares. |
+
+---
+
+## 🏗️ **Architecture: The Hybrid Pipeline**
+
+```mermaid
+graph LR
+    A[User Code] -->|Request Fit/Predict| B{Smart Dispatcher}
+    B -->|Small N < 64| C["CPU Engine
+    (NumPy AVX2)"]
+    B -->|Large N >= 64| D["GPU Engine
+    (OpenCL Kernels)"]
+    C --> E[Result]
+    D --> E
+    subgraph GPU_Acceleration[GPU Acceleration]
+    D --> F[Matrix Multiply]
+    D --> G[Log-Sum-Exp]
+    D --> H[Parallel Viterbi]
+    end
+```
+
+The library handles the hardware. You handle the math.
+
+## ⚡ Performance: Benchmarks
+
+**Task**: Viterbi Decoding (64 Hidden States, 5000 Days of Data).  
+**Hardware**: AMD Ryzen 680M (Integrated Graphics).
+
+| Engine | Execution Time | Speedup |
+|--------|---------------|---------|
+| 🐢 CPU (NumPy Optimized) | 5.06s | 1x |
+| 🚀 GPU (MarkovGPU) | 0.82s | **6.2x** |
+
+---
+
+## ⚙️ Quick Start in 30 Seconds
+
+### Installation
+
+```bash
+# Production
+pip install markovgpu-rane
+
+# Or for local development
+uv pip install markovgpu-rane
+```
+
+### 1. Market Regime Detection (Viterbi)
+Identify hidden "Bull" vs. "Bear" markets from noisy stock returns.
+
+```python
+import numpy as np
+from markovgpu import MarkovEngine
+
+# 1. Setup the Rules (Transition Matrix)
+# "Bull markets tend to stay Bullish (95%)"
+trans_mat = np.array([[0.95, 0.05], 
+                      [0.10, 0.90]], dtype=np.float32)
+
+# 2. Feed the Data (Observation Likelihoods)
+# Shape: (1000 Days, 2 States)
+obs_probs = np.random.rand(1000, 2).astype(np.float32) 
+
+# 3. Ignite the Engine
+engine = MarkovEngine()
+predicted_states = engine.decode_regime(trans_mat, obs_probs)
+
+print("Detected Regimes:", predicted_states) 
+# Output: [0, 0, 0, 1, 1, 1, 0 ...]
+```
+
+### 2. Unsupervised Learning (Baum-Welch)
+Train the AI to discover the hidden rules from raw data.
+
+```python
+# The engine learns the Transition Matrix automatically
+learned_matrix = engine.fit(
+    obs_probs, 
+    n_states=2, 
+    n_iters=100, 
+    tolerance=1e-4
+)
+
+print("Discovered Rules:")
+print(learned_matrix)
+```
+
+---
+
+## 🔬 Technical Brilliance
+
+### 1. The Log-Sum-Exp Kernel
+Standard HMMs crash on long sequences because probabilities like $0.9^{1000}$ vanish to zero.
+We solved this by rewriting the entire GPU kernel in Log-Space:
+
+```c
+// Actual OpenCL Kernel snippet
+float log_add(float log_a, float log_b) {
+    float max_val = max(log_a, log_b);
+    return max_val + log1p(exp(min(log_a, log_b) - max_val));
+}
+```
+→ **Result**: You can process sequences of infinite length without numerical collapse.
+
+### 2. Parallel Viterbi
+Instead of a slow Python loop, we launch $N$ threads (one per state) for every time step on the GPU, calculating the optimal path in parallel.
+
+---
+
+## 🛠️ Project Structure
+
+```
+markovgpu/
+├── src/markovgpu/
+│   ├── backend.py       # The Brain (Smart Dispatcher)
+│   ├── kernels.cl       # The Muscle (OpenCL C Code)
+│   └── __init__.py
+├── tests/               # Unit Tests
+├── pyproject.toml       # Modern Packaging Config
+└── README.md
+```
+
+## 🌱 Contributing
+
+We welcome forks, issues, and PRs!
+
+```bash
+git clone https://github.com/wizardwithcodehazard/markov.git
+cd markov
+uv sync --dev
+uv run pytest
+```
+
+## 📄 License
+
+**MIT License** — Free to use, modify, and ship in commercial products.
+
+<div align="center">
+
+MarkovGPU doesn’t just crunch numbers.  
+### It discovers the hidden structure of reality.
+
+Made with 🧡 by Sahil Rane
+
+</div>

markovgpu_rane-0.3.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+markovgpu/__init__.py,sha256=pCxM1YXY4faXxSm_LtdvL742NKkXKGMeNl61-hHcStU,121
+markovgpu/backend.py,sha256=zbqKS0xjBvJRZ_Mu79y_6-HbpZkjbtA-1eQ_xDXc4lQ,13674
+markovgpu/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+markovgpu/sklearn.py,sha256=5N6d4XVJwev4iH7OCPw4TT_nNTc71-CvNdfIW_S2kxI,3469
+markovgpu/kernels.cl,sha256=DLrcHMg01UO6L1h8u9LM_6uwa9ec9hwdOclGdnxg768,6075
+markovgpu_rane-0.3.0.dist-info/METADATA,sha256=y3soPxmx-IlAxPKGBpPvS0IeZTK7sD-8EBZUaBJOj6I,6622
+markovgpu_rane-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+markovgpu_rane-0.3.0.dist-info/RECORD,,

markovgpu_rane-0.1.0.dist-info/METADATA

@@ -1,22 +0,0 @@
-Metadata-Version: 2.4
-Name: markovgpu-rane
-Version: 0.1.0
-Summary: High-performance Markov Chains & HMMs using OpenCL
-Author-email: Sahil Rane <sahilrane249@gmail.com>
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Financial and Insurance Industry
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Requires-Python: >=3.12
-Requires-Dist: matplotlib>=3.8.0
-Requires-Dist: numpy>=1.26.0
-Requires-Dist: pyopencl>=2024.1
-Requires-Dist: scipy>=1.11.0
-Description-Content-Type: text/markdown
-
-hello

markovgpu_rane-0.1.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-markovgpu/__init__.py,sha256=aGWvFGT6VaLCuFNO9T3ubnlhz2qgkBmNIcCy976YrqE,62
-markovgpu/backend.py,sha256=bfYnge9MgMcDHmJ7CcCG2VGqVfsGxsCzXavGLUFdB2w,11733
-markovgpu/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-markovgpu/kernels.cl,sha256=RXpt2jD6IRdh5YTunB_lwfajT1Cw9M95v3uxwMMmMvs,5141
-markovgpu_rane-0.1.0.dist-info/METADATA,sha256=-CqRDK-d95CjNbsFpBIBut--zqLGHvvXPgsWdUe0Mtg,840
-markovgpu_rane-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-markovgpu_rane-0.1.0.dist-info/RECORD,,