markovgpu-rane 0.1.0__tar.gz

markovgpu_rane-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,27 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]  # Runs ONLY when you click "Create Release" on GitHub
+
+jobs:
+  pypi-publish:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    environment: pypi  # Matches what you typed in PyPI website
+    permissions:
+      id-token: write  # REQUIRED for Trusted Publishing
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Build Package
+        run: uv build
+
+      - name: Publish to PyPI
+        # This action uses the "Trusted" connection automatically
+        uses: pypa/gh-action-pypi-publish@release/v1

markovgpu_rane-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,37 @@
+name: CI (Test & Lint)
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Test on Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]  # Test multiple versions
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5  # The official uv action
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install Project
+        run: uv sync --all-extras --dev
+
+      - name: Lint Code (Ruff)
+        run: |
+          uv run ruff check .
+          uv run ruff format --check .
+
+      - name: Run Tests
+        # We assume CPU fallback works (GitHub runners don't have GPUs)
+        run: uv run pytest

markovgpu_rane-0.1.0/.gitignore

@@ -0,0 +1,76 @@
+# --- Python Basics ---
+__pycache__/
+*.py[cod]
+*$py.class
+
+# --- C Extensions & Shared Libraries ---
+*.so
+*.pyd
+*.dylib
+
+# --- Distribution / Packaging ---
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# --- Virtual Environments ---
+# Common names for virtual envs
+.venv
+venv/
+ENV/
+env/
+
+# --- Unit Test / Coverage ---
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+
+# --- IDEs & Editors (Optional but Recommended) ---
+# VS Code
+.vscode/
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+*.code-workspace
+
+# PyCharm / IntelliJ
+.idea/
+
+# Mac / Windows System Files
+.DS_Store
+Thumbs.db
+
+# --- Environment Variables (Security) ---
+# NEVER commit your secrets
+.env
+.env.local
+.env.*.local
+
+# --- Project Specific ---
+# If your OpenCL kernels generate binary caches
+*.cl.bin

markovgpu_rane-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

markovgpu_rane-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+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/README.md

@@ -0,0 +1 @@
+hello

markovgpu_rane-0.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[project]
+name = "markovgpu-rane" 
+version = "0.1.0"
+description = "High-performance Markov Chains & HMMs using OpenCL"
+readme = "README.md"
+authors = [
+    { name = "Sahil Rane", email = "sahilrane249@gmail.com" }
+]
+requires-python = ">=3.12"
+
+# Your core libraries + visualization/stats tools you used in the demos
+dependencies = [
+    "numpy>=1.26.0",       # Relaxed version constraint slightly for better compatibility
+    "pyopencl>=2024.1",
+    "matplotlib>=3.8.0",
+    "scipy>=1.11.0",
+]
+
+# Metadata tags to help people find your library on PyPI
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+
+# (Optional) Add your GitHub URL if you have pushed the code
+# [project.urls]
+# Repository = "https://github.com/yourusername/markovgpu"
+# Issues = "https://github.com/yourusername/markovgpu/issues"
+
+# ---------------------------------------------------------
+# BUILD SYSTEM: Hatchling (Standard for uv)
+# ---------------------------------------------------------
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+# ---------------------------------------------------------
+# PACKAGING: Include the .cl Kernel file
+# ---------------------------------------------------------
+[tool.hatch.build.targets.wheel]
+packages = ["src/markovgpu"]
+
+[tool.hatch.build.targets.wheel.force-include]
+# Map source path (left) to package destination (right)
+"src/markovgpu/kernels.cl" = "markovgpu/kernels.cl"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "ruff>=0.15.0",
+]

markovgpu_rane-0.1.0/src/markovgpu/__init__.py

@@ -0,0 +1,3 @@
+from .backend import MarkovEngine
+
+__all__ = ["MarkovEngine"]

markovgpu_rane-0.1.0/src/markovgpu/backend.py

@@ -0,0 +1,326 @@
+import pyopencl as cl
+import numpy as np
+import os
+
+# Locate the kernel file
+MODULE_PATH = os.path.dirname(os.path.abspath(__file__))
+KERNEL_PATH = os.path.join(MODULE_PATH, "kernels.cl")
+
+# Threshold: Use GPU if states >= 64, otherwise CPU is faster
+GPU_THRESHOLD = 64
+
+
+class MarkovEngine:
+    def __init__(self):
+        self.use_gpu = False
+        self.ctx = None
+        self.queue = None
+        self.prg = None
+
+        # 1. Try to Connect to GPU
+        try:
+            platforms = cl.get_platforms()
+            gpu_devices = []
+            for p in platforms:
+                gpu_devices.extend(p.get_devices(device_type=cl.device_type.GPU))
+
+            if gpu_devices:
+                # Pick the discrete GPU (highest compute units)
+                best_dev = sorted(
+                    gpu_devices, key=lambda d: d.max_compute_units, reverse=True
+                )[0]
+                self.ctx = cl.Context([best_dev])
+                print(
+                    f"🔌 Connected to Accelerator: {best_dev.name} ({best_dev.max_compute_units} CUs)"
+                )
+            else:
+                self.ctx = cl.create_some_context(interactive=False)
+                print(f"⚠️ No Dedicated GPU found. Using: {self.ctx.devices[0].name}")
+
+            self.queue = cl.CommandQueue(self.ctx)
+
+            # 2. Compile Kernels
+            if not os.path.exists(KERNEL_PATH):
+                raise FileNotFoundError(f"Kernel file missing at: {KERNEL_PATH}")
+
+            with open(KERNEL_PATH, "r") as f:
+                self.prg = cl.Program(self.ctx, f.read()).build()
+
+            # 3. Cache Kernels (Robust Retrieval)
+            self.use_gpu = True
+            try:
+                # Basic
+                self.k_markov = self.prg.markov_step
+                self.k_hmm_basic = self.prg.hmm_forward_step
+
+                # Advanced / Viterbi
+                self.k_hmm_log = self.prg.hmm_forward_log
+                self.k_viterbi = self.prg.viterbi_step
+
+                # Training
+                self.k_hmm_back = self.prg.hmm_backward_log
+                self.k_acc_trans = self.prg.accumulate_transitions
+                self.k_acc_gamma = self.prg.accumulate_gammas
+
+            except AttributeError as e:
+                print(f"❌ Kernel Warning: {e}")
+                print("⚠️ Some GPU features may be disabled.")
+
+        except Exception as e:
+            print(f"⚠️ OpenCL Initialization failed: {e}")
+            print("⚠️ Running in CPU-Only Mode (NumPy).")
+            self.use_gpu = False
+
+    # --- 1. Simulation ---
+    def step(self, P, v):
+        """Runs one step: v_new = v * P"""
+        N = len(v)
+
+        if not self.use_gpu or N < GPU_THRESHOLD:
+            return v.dot(P)
+
+        mf = cl.mem_flags
+        P = np.ascontiguousarray(P, 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_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)
+        cl.enqueue_copy(self.queue, result, d_res)
+        return result
+
+    def converge(self, P, start_v, tolerance=1e-5, max_steps=1000):
+        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)
+                if np.sum(np.abs(new_v - current_v)) < tolerance:
+                    return new_v
+                current_v = new_v
+            return current_v
+
+        # GPU Path
+        # print(f"🔄 Converging on GPU (N={N})...")
+        mf = cl.mem_flags
+        P = np.ascontiguousarray(P, 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_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)
+
+            if i % 10 == 0:
+                new_v = np.empty_like(current_v)
+                cl.enqueue_copy(self.queue, new_v, d_v_write)
+                if np.sum(np.abs(new_v - current_v)) < tolerance:
+                    return new_v
+                current_v = new_v
+
+            d_v_read, d_v_write = d_v_write, d_v_read
+
+        print("⚠️ Reached max steps without full convergence.")
+        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
+        epsilon = 1e-20
+
+        # CPU Path
+        if not self.use_gpu or N < GPU_THRESHOLD:
+            log_trans = np.log(transition_matrix + epsilon)
+            log_emis = np.log(observation_probs + epsilon)
+            log_delta = np.zeros((T, N))
+            backpointers = np.zeros((T, N), dtype=int)
+
+            log_delta[0] = -np.log(N) + log_emis[0]
+
+            for t in range(1, T):
+                for j in range(N):
+                    vals = log_delta[t - 1] + log_trans[:, j]
+                    best_prev = np.argmax(vals)
+                    backpointers[t, j] = best_prev
+                    log_delta[t, j] = vals[best_prev] + log_emis[t, j]
+
+            path = np.zeros(T, dtype=int)
+            path[-1] = np.argmax(log_delta[-1])
+            for t in range(T - 2, -1, -1):
+                path[t] = backpointers[t + 1, path[t + 1]]
+            return path
+
+        # GPU Path
+        mf = cl.mem_flags
+        log_trans = np.log(transition_matrix + epsilon).astype(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_delta_out = cl.Buffer(self.ctx, mf.READ_WRITE, size=log_delta.nbytes)
+
+        full_backpointer_history = np.zeros((T, N), dtype=np.int32)
+        d_backpointers = cl.Buffer(
+            self.ctx, mf.WRITE_ONLY, size=full_backpointer_history.nbytes // T
+        )
+
+        print(f"🕵️ Decoding {T} days (GPU Accelerated)...")
+
+        for t in range(T):
+            d_emis = cl.Buffer(
+                self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=log_emis[t]
+            )
+
+            self.k_viterbi(
+                self.queue,
+                (N,),
+                None,
+                np.int32(N),
+                d_delta_in,
+                d_trans,
+                d_emis,
+                d_delta_out,
+                d_backpointers,
+            )
+
+            step_pointers = np.empty(N, dtype=np.int32)
+            cl.enqueue_copy(self.queue, step_pointers, d_backpointers)
+            full_backpointer_history[t] = step_pointers
+
+            d_delta_in, d_delta_out = d_delta_out, d_delta_in
+
+        final_log_probs = np.empty(N, dtype=np.float32)
+        cl.enqueue_copy(self.queue, final_log_probs, d_delta_in)
+
+        best_path = np.zeros(T, dtype=np.int32)
+        best_path[-1] = np.argmax(final_log_probs)
+
+        for t in range(T - 2, -1, -1):
+            next_state = best_path[t + 1]
+            best_path[t] = full_backpointer_history[t + 1][next_state]
+
+        return best_path
+
+    # --- 3. Training (Baum-Welch) ---
+    def fit(self, observations, n_states, n_iters=10, tolerance=1e-4):
+        """Baum-Welch Expectation Maximization (Training)"""
+        T = observations.shape[0]
+        N = n_states
+
+        # Random Init
+        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)
+
+        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)...")
+
+        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)
+
+            # 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)
+
+            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.k_acc_gamma(
+                self.queue,
+                (N,),
+                None,
+                np.int32(T),
+                np.int32(N),
+                d_alpha,
+                d_beta,
+                d_gamma_sums,
+            )
+
+            # 3. Update
+            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)
+
+            log_trans = new_log_trans_counts - log_gamma_sums[:, None]
+
+            change = log_likelihood - prev_score
+            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