laya 0.1.0__py3-none-any.whl

laya/__init__.py

@@ -0,0 +1,15 @@
+"""Laya: Fast, non-autoregressive System 1 decision engine with calibrated probabilities."""
+
+from .agent import Agent, RLAgent, load
+from .email import clean_email_body, email_questions, email_state
+
+__version__ = "0.1.0"
+__all__ = [
+    "Agent",
+    "RLAgent",
+    "load",
+    "clean_email_body",
+    "email_questions",
+    "email_state",
+    "__version__",
+]

laya/agent.py

@@ -0,0 +1,200 @@
+"""High-level inference runtime for laya System 1 decision models."""
+import json
+import os
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+import torch
+
+from .common import (
+    QTYPES,
+    amp_dtype,
+    build_model,
+    build_sequence,
+    collate_items,
+    confidence_from_probs,
+    render_options,
+    temp_bucket,
+)
+
+
+def _fix_tokenizer_config(path: str):
+    """Ensure tokenizer_config.json can be loaded across all transformers versions."""
+    cfg_file = os.path.join(path, "tokenizer", "tokenizer_config.json")
+    if not os.path.exists(cfg_file):
+        return
+    try:
+        with open(cfg_file) as f:
+            tcfg = json.load(f)
+        if tcfg.get("tokenizer_class") in (None, "TokenizersBackend"):
+            tcfg["tokenizer_class"] = "PreTrainedTokenizerFast"
+            tcfg.pop("backend", None)
+            tcfg.pop("is_local", None)
+            with open(cfg_file, "w") as f:
+                json.dump(tcfg, f, indent=2)
+    except Exception:
+        pass
+
+
+class Agent:
+    """System 1 decision model runtime: fast, non-autoregressive, calibrated decisions."""
+
+    def __init__(
+        self,
+        model_id_or_path: str = "convaiinnovations/rl-agent",
+        device: Optional[str] = None,
+        token: Optional[str] = None,
+    ):
+        from safetensors.torch import load_file
+        from transformers import AutoTokenizer
+
+        model_dir = model_id_or_path
+        if not os.path.exists(model_dir):
+            from huggingface_hub import snapshot_download
+
+            model_dir = snapshot_download(model_id_or_path, token=token or os.environ.get("HF_TOKEN"))
+
+        _fix_tokenizer_config(model_dir)
+
+        cfg_path = os.path.join(model_dir, "rl_agent_config.json")
+        with open(cfg_path) as f:
+            self.cfg = json.load(f)
+
+        if device is None:
+            if torch.cuda.is_available():
+                self.device = torch.device("cuda")
+            elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+                self.device = torch.device("mps")
+            else:
+                self.device = torch.device("cpu")
+        else:
+            self.device = torch.device(device)
+
+        tok_dir = os.path.join(model_dir, "tokenizer")
+        self.tok = AutoTokenizer.from_pretrained(tok_dir if os.path.exists(tok_dir) else self.cfg.get("encoder"))
+
+        enc_dir = os.path.join(model_dir, "encoder")
+        self.model = build_model(self.cfg, encoder_dir=enc_dir if os.path.exists(enc_dir) else None)
+
+        weights_path = os.path.join(model_dir, "model.safetensors")
+        self.model.load_state_dict(load_file(weights_path), strict=True)
+        self.model.to(self.device).eval()
+
+        self.temperature = self.cfg.get("temperature", [1.0, 1.0, 1.0])
+        self.temperature_by_options = self.cfg.get("temperature_by_options", {})
+        self.dtype = amp_dtype(self.cfg.get("amp_dtype", "fp16"))
+
+        if self.device.type == "cuda" and torch.cuda.get_device_capability(self.device)[0] < 8:
+            self.dtype = torch.float16
+        elif self.device.type in ("cpu", "mps"):
+            self.dtype = torch.float32
+
+    @staticmethod
+    def _to_internal(qdef: Dict) -> Dict:
+        t = qdef["type"]
+        crit = qdef.get("criteria")
+        if t == "choice" and isinstance(crit, list):
+            crit = {c: None for c in crit}
+        ins = qdef["instructions"]
+        if not isinstance(ins, str):
+            ins = json.dumps(ins)
+        return {"t": t, "ins": ins, "crit": crit}
+
+    @torch.no_grad()
+    def system_one(self, state: Union[str, dict, list], questions: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
+        """Evaluate typed questions across state in a single, parallel forward pass.
+
+        Args:
+            state: Text string, JSON dict, or conversation turn list.
+            questions: Dictionary mapping question_id -> question definition.
+                - choice: {"type": "choice", "instructions": "...", "criteria": {"optA": "...", ...}}
+                - score:  {"type": "score",  "instructions": "...", "criteria": ["lvl0", "lvl1", ...]}
+                - noul:   {"type": "noul",   "instructions": "..."}
+
+        Returns:
+            Dictionary with answers, probabilities, calibrated confidence, and token usage.
+        """
+        ids = list(questions.keys())
+        items = []
+        max_len = self.cfg.get("max_len", 512)
+        head_max_len = self.cfg.get("head_max_len", 192)
+
+        for qid in ids:
+            q = self._to_internal(questions[qid])
+            seq, markers = build_sequence(self.tok, state, q, max_len, head_max_len)
+            if len(markers) != len(render_options(q)):
+                raise ValueError("question %r options exceed head_max_len=%d" % (qid, head_max_len))
+            items.append({"ids": seq, "markers": markers, "qtype": QTYPES[q["t"]]})
+
+        b = collate_items([items], self.tok.pad_token_id)
+        use_amp = self.device.type == "cuda"
+
+        with torch.autocast(device_type=self.device.type, dtype=self.dtype, enabled=use_amp):
+            logits, act = self.model(
+                b["input_ids"].to(self.device),
+                b["attention_mask"].to(self.device),
+                b["marker_pos"].to(self.device),
+                b["marker_mask"].to(self.device),
+                b["qtype"].to(self.device),
+            )
+
+        logits = logits.float().cpu().numpy()
+        act = torch.softmax(act.float(), -1).cpu().numpy()
+
+        answers = {}
+        n_tokens = int(b["attention_mask"].sum())
+
+        for r, qid in enumerate(ids):
+            q = self._to_internal(questions[qid])
+            k = len(items[r]["markers"])
+            qt = QTYPES[q["t"]]
+            t_scale = self.temperature_by_options.get(temp_bucket(qt, k), self.temperature[qt])
+            z = logits[r, :k] / max(1e-3, float(t_scale))
+            p = np.exp(z - z.max())
+            p = p / p.sum()
+
+            conf_score = round(confidence_from_probs(p, k), 4)
+            ext = {"act_probability": round(float(act[r, 0]), 4)}
+
+            if q["t"] == "choice":
+                keys = list(q["crit"].keys())
+                answers[qid] = {
+                    "type": "choice",
+                    "choice": keys[int(p.argmax())],
+                    "probabilities": {kk: round(float(v), 4) for kk, v in zip(keys, p)},
+                    "confidence": conf_score,
+                    "action": ext,
+                }
+            elif q["t"] == "score":
+                exp_score = float((np.arange(k) * p).sum())
+                answers[qid] = {
+                    "type": "score",
+                    "score": round(exp_score, 4),
+                    "legend": {str(i): c for i, c in enumerate(q["crit"])},
+                    "probabilities": {str(i): round(float(v), 4) for i, v in enumerate(p)},
+                    "confidence": conf_score,
+                    "action": ext,
+                }
+            else:
+                answers[qid] = {
+                    "type": "noul",
+                    "noul": round(float(p[1]), 4),
+                    "confidence": round(max(float(p[1]), 1.0 - float(p[1])), 4),
+                    "action": ext,
+                }
+
+        return {
+            "model": "laya-rl-agent",
+            "answers": answers,
+            "usage": {"input_tokens": n_tokens, "output_tokens": 0},
+        }
+
+    predict = system_one
+
+
+RLAgent = Agent
+
+
+def load(model_id_or_path: str = "convaiinnovations/rl-agent", device: Optional[str] = None, token: Optional[str] = None) -> Agent:
+    """Helper function to load a Laya agent model."""
+    return Agent(model_id_or_path, device=device, token=token)

laya/common.py

@@ -0,0 +1,167 @@
+"""Core model architecture, token sequence construction, and confidence estimation for laya."""
+import json
+import math
+import os
+from typing import Dict, List, Optional, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+QTYPES = {"choice": 0, "score": 1, "noul": 2}
+QTYPE_NAMES = {v: k for k, v in QTYPES.items()}
+
+
+def serialize_state(state: Union[str, dict, list]) -> str:
+    if isinstance(state, str):
+        return state
+    return json.dumps(state, ensure_ascii=False)
+
+
+def render_options(q: Dict) -> List[str]:
+    """Render option texts in label-index order. Noul is always [false, true]."""
+    t, crit = q["t"], q.get("crit")
+    if t == "choice":
+        return [k if not v else "%s: %s" % (k, v) for k, v in crit.items()]
+    if t == "score":
+        return ["level %d: %s" % (i, c) for i, c in enumerate(crit)]
+    crit = crit or {}
+    return [
+        "false: " + (crit.get("false") or "no, the statement does not hold"),
+        "true: " + (crit.get("true") or "yes, the statement holds"),
+    ]
+
+
+def build_sequence(
+    tok,
+    state: Union[str, dict, list],
+    q: Dict,
+    max_len: int = 512,
+    head_max_len: int = 192,
+    option_order: Optional[List[int]] = None,
+    truncate_left: bool = False,
+):
+    """Format: [CLS] <type> instructions [SEP] [MASK] opt0 [MASK] opt1 ... [SEP] state [SEP]."""
+    mask_tok = tok.mask_token
+    opts = render_options(q)
+    order = option_order if option_order is not None else list(range(len(opts)))
+    ins = str(q["ins"]).replace(mask_tok, " ")
+    head_ids = tok("%s question: %s" % (q["t"], ins), add_special_tokens=False)["input_ids"]
+    opt_ids = []
+    for i in order:
+        opt_ids.append(
+            [tok.mask_token_id]
+            + tok(" " + opts[i].replace(mask_tok, " "), add_special_tokens=False)["input_ids"][:48]
+        )
+    opt_budget = head_max_len - sum(len(o) for o in opt_ids)
+    if opt_budget < 16:
+        per = max(4, (head_max_len - 16) // max(1, len(opt_ids)))
+        opt_ids = [o[:per] for o in opt_ids]
+        opt_budget = head_max_len - sum(len(o) for o in opt_ids)
+    head_ids = head_ids[: max(8, opt_budget)]
+    ids = [tok.cls_token_id] + head_ids + [tok.sep_token_id]
+    markers = []
+    for o in opt_ids:
+        markers.append(len(ids))
+        ids.extend(o)
+    ids.append(tok.sep_token_id)
+    room = max(0, max_len - len(ids) - 1)
+    st = tok(serialize_state(state).replace(mask_tok, " "), add_special_tokens=False)["input_ids"]
+    st = st[-room:] if truncate_left else st[:room]
+    ids = ids + st + [tok.sep_token_id]
+    return ids[:max_len], [m for m in markers if m < max_len]
+
+
+class DecisionModel(nn.Module):
+    """Bidirectional transformer encoder backbone + typed decision head."""
+
+    def __init__(self, encoder: nn.Module, head_layers: int = 2, n_act: int = 2, dropout: float = 0.1):
+        super().__init__()
+        self.encoder = encoder
+        d = encoder.config.hidden_size
+        nhead = max(1, d // 64)
+        layer = nn.TransformerEncoderLayer(d, nhead, 4 * d, dropout, batch_first=True, norm_first=True)
+        self.head = nn.TransformerEncoder(layer, head_layers, enable_nested_tensor=False) if head_layers > 0 else None
+        self.type_emb = nn.Embedding(3, d)
+        self.scorer = nn.Sequential(nn.LayerNorm(d), nn.Linear(d, d), nn.GELU(), nn.Linear(d, 1))
+        self.act_head = nn.Sequential(nn.Linear(d + 4, 256), nn.GELU(), nn.Linear(256, n_act))
+        self.register_buffer("temperature", torch.ones(3))
+        self.head_checkpointing = False
+
+    def forward(self, input_ids, attention_mask, marker_pos, marker_mask, qtype, detach_encoder: bool = False):
+        h = self.encoder(input_ids=input_ids, attention_mask=attention_mask).last_hidden_state
+        if detach_encoder:
+            h = h.detach()
+        h = h + self.type_emb(qtype)[:, None, :]
+        if self.head is not None:
+            pad = ~attention_mask.bool()
+            for layer in self.head.layers:
+                h = layer(h, src_key_padding_mask=pad)
+        idx = marker_pos.clamp(min=0)[:, :, None].expand(-1, -1, h.size(-1))
+        m = torch.gather(h, 1, idx)
+        logits = self.scorer(m).squeeze(-1).float()
+        logits = logits.masked_fill(~marker_mask, -1e4)
+
+        p = torch.softmax(logits.detach(), -1)
+        k = marker_mask.sum(-1).clamp(min=2).float()
+        ent = -(p * torch.log(p.clamp_min(1e-9))).sum(-1) / torch.log(k)
+        top2 = p.topk(2, -1).values
+        feats = torch.stack([top2[:, 0], top2[:, 0] - top2[:, 1], ent, k / 255.0], -1)
+        pooled = h[:, 0].float()
+        act_logits = self.act_head(torch.cat([pooled, feats], -1))
+        return logits, act_logits
+
+
+def build_model(cfg: Dict, encoder_dir: Optional[str] = None) -> DecisionModel:
+    from transformers import AutoConfig, AutoModel
+
+    if encoder_dir and os.path.exists(encoder_dir):
+        ecfg = AutoConfig.from_pretrained(encoder_dir)
+        enc = AutoModel.from_config(ecfg, attn_implementation="sdpa")
+    else:
+        enc = AutoModel.from_pretrained(cfg["encoder"], attn_implementation="sdpa")
+    return DecisionModel(enc, cfg.get("head_layers", 2), len(cfg.get("act_costs", {})) + 1)
+
+
+def confidence_from_probs(p: np.ndarray, k: int) -> float:
+    """Normalized Shannon entropy confidence: 1 - H(p) / log(k)."""
+    if k < 2:
+        return 1.0
+    p = p[:k]
+    ent = -(p * np.log(np.clip(p, 1e-12, 1.0))).sum()
+    return float(np.clip(1.0 - ent / math.log(k), 0.0, 1.0))
+
+
+def temp_bucket(qtype: int, k: int) -> str:
+    size = "2" if k <= 2 else "3-5" if k <= 5 else "6-10" if k <= 10 else "11+"
+    return "%s:%s" % (QTYPE_NAMES[int(qtype)], size)
+
+
+def amp_dtype(name: Optional[str]) -> torch.dtype:
+    return torch.bfloat16 if name == "bf16" else torch.float16
+
+
+def collate_items(batch, pad_id: int):
+    items = [it for group in batch for it in group]
+    if not items:
+        return None
+    n, L = len(items), max(len(it["ids"]) for it in items)
+    kmax = max(len(it["markers"]) for it in items)
+    ids = torch.full((n, L), pad_id, dtype=torch.long)
+    att = torch.zeros((n, L), dtype=torch.long)
+    mpos = torch.zeros((n, kmax), dtype=torch.long)
+    mmask = torch.zeros((n, kmax), dtype=torch.bool)
+    for i, it in enumerate(items):
+        ids[i, : len(it["ids"])] = torch.tensor(it["ids"])
+        att[i, : len(it["ids"])] = 1
+        k = len(it["markers"])
+        mpos[i, :k] = torch.tensor(it["markers"])
+        mmask[i, :k] = True
+    return {
+        "input_ids": ids,
+        "attention_mask": att,
+        "marker_pos": mpos,
+        "marker_mask": mmask,
+        "qtype": torch.tensor([it["qtype"] for it in items]),
+        "meta": [{k: it[k] for k in it if k not in ("ids", "markers")} for it in items],
+    }

laya/email.py

@@ -0,0 +1,90 @@
+"""Email utilities for cleaning and structuring email inputs in laya."""
+import re
+from typing import Dict, Optional
+
+_QUOTE_HEADERS = [
+    re.compile(r"^\s*On .{0,300}wrote:\s*$", re.I),
+    re.compile(r"^\s*-{2,}\s*(Original|Forwarded) Message\s*-{2,}", re.I),
+    re.compile(r"^\s*_{8,}\s*$"),
+    re.compile(r"^\s*From:\s.+$", re.I),
+]
+_SIGNATURE_MARKERS = [
+    re.compile(r"^\s*--\s*$"),
+    re.compile(r"^\s*(best|kind|warm|many thanks|thanks|thank you|regards|cheers|sincerely)[\w ,!.]*$", re.I),
+    re.compile(r"^\s*sent from my (iphone|android|mobile|ipad)", re.I),
+]
+_DISCLAIMER = re.compile(
+    r"(confidential|intended (solely )?for the (use of the )?(named )?(addressee|recipient)|"
+    r"if you (have )?received this (e-?mail|message) in error)",
+    re.I,
+)
+
+
+def clean_email_body(body: str, max_chars: int = 3000) -> str:
+    """Remove quoted email history, signatures and disclaimers to keep input focused."""
+    text = (body or "").replace("\r\n", "\n").replace("\r", "\n").replace("\\n", "\n")
+    lines = []
+    for line in text.split("\n"):
+        if any(p.match(line) for p in _QUOTE_HEADERS) and lines:
+            break
+        if line.lstrip().startswith(">"):
+            continue
+        lines.append(line.rstrip())
+    cut = len(lines)
+    for i in range(max(1, min(int(len(lines) * 0.6), len(lines) - 8)), len(lines)):
+        if len(lines[i].strip()) <= 40 and any(p.match(lines[i]) for p in _SIGNATURE_MARKERS):
+            cut = i
+            break
+    lines = lines[:cut]
+    paragraphs = [p for p in re.split(r"\n\s*\n", "\n".join(lines)) if not _DISCLAIMER.search(p)]
+    text = re.sub(r"[ \t]+", " ", "\n\n".join(p.strip() for p in paragraphs if p.strip()))
+    return text[:max_chars]
+
+
+def email_state(subject: str, body: str, sender: Optional[str] = None, clean: bool = True, **extra) -> Dict:
+    """Construct a clean state dictionary for email classification."""
+    state = {
+        "subject": (subject or "").strip(),
+        "body": clean_email_body(body) if clean else (body or ""),
+    }
+    if sender:
+        state["from"] = sender
+    state.update({k: v for k, v in extra.items() if v is not None})
+    return state
+
+
+def email_questions(categories: Optional[Dict[str, str]] = None) -> Dict:
+    """Standard pre-built questions for email triage."""
+    categories = categories or {
+        "billing": "invoices, payments, refunds",
+        "technical": "bugs, outages, integrations",
+        "sales": "pricing, demos, new purchases",
+        "security": "phishing, scams, account compromise",
+        "hr": "hiring, leave, payroll",
+        "other": "none of the above",
+    }
+    return {
+        "category": {
+            "type": "choice",
+            "instructions": "Which team should handle the email in `body`?",
+            "criteria": categories,
+        },
+        "is_spam": {
+            "type": "noul",
+            "instructions": "Is this email unsolicited spam or bulk marketing?",
+        },
+        "is_phishing": {
+            "type": "noul",
+            "instructions": "Is this email a phishing or scam attempt to steal money, credentials, or personal data?",
+            "criteria": {"true": "phishing, scam, or fraud", "false": "a legitimate email"},
+        },
+        "urgency": {
+            "type": "score",
+            "instructions": "How urgent is the request in `body`?",
+            "criteria": ["no time pressure", "needs attention soon", "blocking issue or hard deadline"],
+        },
+        "needs_reply": {
+            "type": "noul",
+            "instructions": "Does the sender expect a reply?",
+        },
+    }

laya-0.1.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: laya
+Version: 0.1.0
+Summary: Fast, non-autoregressive System 1 decision engine with calibrated probabilities
+Author: Convai Innovations
+License: Apache-2.0
+Project-URL: Homepage, https://huggingface.co/convaiinnovations/rl-agent
+Project-URL: Demo, https://huggingface.co/spaces/convaiinnovations/rl-agent-demo
+Keywords: decision-model,rlcd,calibration,system-one,routing,guardrails,moderation,triage
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: torch>=2.0.0
+Requires-Dist: transformers>=4.45.0
+Requires-Dist: safetensors>=0.4.0
+Requires-Dist: huggingface_hub>=0.20.0
+Requires-Dist: numpy>=1.20.0
+Dynamic: requires-python
+
+# Laya (लय)
+
+Fast, non-autoregressive System 1 decision engine with mathematically calibrated probabilities.
+
+Laya lets you evaluate typed questions (`choice`, `score`, `noul`) over any state (text, email, ticket, or JSON document) in **a single forward pass (~33–38 ms on GPU)**. It produces structured decision outputs and calibrated confidence scores without text generation, token streaming, or hallucinations.
+
+Compatible with [RL Agent models on Hugging Face](https://huggingface.co/convaiinnovations/rl-agent).
+
+---
+
+## Installation
+
+```bash
+pip install laya
+```
+
+---
+
+## Quickstart
+
+```python
+import laya
+
+# 1. Load the model from Hugging Face Hub (auto-downloads weights)
+agent = laya.load("convaiinnovations/rl-agent")
+
+# 2. Provide any state (string or dictionary)
+state = {
+    "from": "user@acme.com",
+    "subject": "Duplicate charge on invoice #4411",
+    "body": "Hi, we were billed twice for March. Please refund the duplicate today or we will cancel our plan."
+}
+
+# 3. Define your typed questions
+questions = {
+    # choice: categorical selection with probabilities & confidence
+    "department": {
+        "type": "choice",
+        "instructions": "Which department should handle this email?",
+        "criteria": {
+            "billing": "invoices, payments, refunds",
+            "technical": "bugs, outages, system errors",
+            "sales": "pricing, new contracts",
+            "other": "everything else"
+        }
+    },
+    # score: placement on an ordinal rubric
+    "urgency": {
+        "type": "score",
+        "instructions": "How urgent is this request?",
+        "criteria": ["not urgent", "soon", "critical deadline or blocking issue"]
+    },
+    # noul: calibrated boolean probability P(true)
+    "churn_risk": {
+        "type": "noul",
+        "instructions": "Does the user threaten to cancel or leave?"
+    },
+    "is_phishing": {
+        "type": "noul",
+        "instructions": "Is this email a phishing or scam attempt?"
+    }
+}
+
+# 4. Run all questions in ONE single forward pass (~35 ms on GPU)
+result = agent.predict(state, questions)
+answers = result["answers"]
+
+print("Department :", answers["department"]["choice"])
+# -> billing (confidence: 0.94)
+
+print("Urgency    :", answers["urgency"]["score"])
+# -> 1.84 / 2.0
+
+print("Churn Risk :", answers["churn_risk"]["noul"])
+# -> 0.892 (89.2% probability)
+
+print("Phishing   :", answers["is_phishing"]["noul"])
+# -> 0.008 (0.8% probability)
+```
+
+---
+
+## Automated Confidence Gating
+
+Because Laya's probabilities are trained with strictly proper scoring rules (RLCD), confidence scores are statistically meaningful:
+
+```python
+dept = answers["department"]["choice"]
+conf = answers["department"]["confidence"]
+
+if conf >= 0.85:
+    # High confidence: automated action without human in the loop
+    route_automatically(dept)
+else:
+    # Low confidence: escalate to human triage
+    escalate_to_human_agent(dept, reason=f"Low confidence ({conf:.2f})")
+```
+
+---
+
+## Decision Primitives
+
+| Primitive | Output | Use Cases |
+|---|---|---|
+| **`choice`** | Top label, probabilities per option, confidence | Department routing, intent classification, topic categorization |
+| **`score`** | Expected level on ordinal rubric, distribution, confidence | Frustration level, ticket urgency, harm severity |
+| **`noul`** | Calibrated probability $P(\text{true}) \in [0.0, 1.0]$ | Phishing detection, spam filtering, jailbreak detection, churn risk |
+
+---
+
+## Live Demo & Resources
+
+* **Hugging Face Model:** [convaiinnovations/rl-agent](https://huggingface.co/convaiinnovations/rl-agent)
+* **Interactive Web Demo:** [convaiinnovations/rl-agent-demo](https://huggingface.co/spaces/convaiinnovations/rl-agent-demo)
+
+---
+
+## License
+
+Apache 2.0. Developed by Convai Innovations.

laya-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+laya/__init__.py,sha256=2iGbmVceeH3D51eGy_ejlyJJXSG_5wf4ViCF_4H_k1M,362
+laya/agent.py,sha256=G-cZCL_YVjzjWT4XfpBtIm4isdGCXmlJhqSggh7Uuz8,7656
+laya/common.py,sha256=7kt__IyYpWnSowY38AR72qRrSNsjbpmtsT0vhS6MuXA,6706
+laya/email.py,sha256=VROPYET4mL3v29iqugjOW00-Ygg8YWle3wb0bXHEjSw,3606
+laya-0.1.0.dist-info/METADATA,sha256=KRzGX_cEB_HZLAiNCQs4c7CxWNGEqRloqVOn5VR_C-g,4963
+laya-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+laya-0.1.0.dist-info/top_level.txt,sha256=8JpyeuR1X7myxlm4zABQAq_B0Fd6kxcnv-eC2a0P-2U,5
+laya-0.1.0.dist-info/RECORD,,

laya-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

laya-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+laya