Request pilot access

This model is available for evaluation purposes only. Please read the full pilot license below before requesting access.

NOPE Edge — Crisis Classification Model

A fine-tuned model for detecting crisis signals in text — suicidal ideation, self-harm, abuse, violence, and other safety-critical content. Designed for on-premise deployment as part of a safety pipeline.

License: NOPE Edge Pilot License v1.0 — Evaluation use only. Production deployment requires a separate agreement. By downloading or using this model you agree to its terms. This is not an open-source model — redistribution and derivative works are prohibited.

Quick Start

Requirements

Python 3.10+
GPU with 4GB+ VRAM (e.g. RTX 3060, T4, A10, L4) — or CPU (slower)
~4GB disk space

pip install torch transformers accelerate

Usage

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "nopenet/nope-edge-20260215001-pilot"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

def classify(message: str) -> str:
    """Returns 'type|severity|subject' or 'none'."""
    input_ids = tokenizer.apply_chat_template(
        [{"role": "user", "content": message}],
        tokenize=True,
        return_tensors="pt",
        add_generation_prompt=True
    ).to(model.device)

    with torch.no_grad():
        output = model.generate(input_ids, max_new_tokens=30, do_sample=False)

    return tokenizer.decode(
        output[0][input_ids.shape[1]:],
        skip_special_tokens=True
    ).strip()

classify("I want to end it all")                    # → "suicide|high|self"
classify("Great day at work!")                       # → "none"
classify("My friend said she wants to kill herself") # → "suicide|high|other"

Output Format

Crisis detected:

{type}|{severity}|{subject}

Field	Values	Description
type	`suicide`, `self_harm`, `self_neglect`, `violence`, `abuse`, `sexual_violence`, `exploitation`, `stalking`, `neglect`	Risk category
severity	`mild`, `moderate`, `high`, `critical`	Urgency level
subject	`self`, `other`	Who is at risk (see below)

No crisis: none

Subject Attribution

The subject field indicates who is at risk:

Subject	Meaning	Example
`self`	The speaker is at risk or is the victim	"I want to kill myself", "My partner hits me"
`other`	The speaker is reporting concern about someone else	"My friend said she wants to die", "My son has been cutting himself"

When self fires:

First-person crisis disclosures ("I want to end it all")
Speaker is the victim of abuse/violence ("He hits me")
Distancing language that likely refers to self ("Asking for a friend...")

When other fires:

Explicit third-party reports ("My brother is suicidal")
Concern about family/friends ("I'm worried about my daughter")

Important: Subject attribution is not always reliable. We recommend treating all detected crises as serious enough to warrant escalation or flagging, regardless of subject. The subject field is informational — it should not be used to dismiss or deprioritize a crisis.

Examples

Input	Output	Explanation
"I want to kill myself"	`suicide\|high\|self`	Speaker is at risk
"My friend said she wants to die"	`suicide\|high\|other`	Speaker reporting third party
"Great weather today"	`none`	No crisis detected

Parsing the Output

from dataclasses import dataclass
from typing import Optional

@dataclass
class Classification:
    is_crisis: bool
    risk_type: Optional[str] = None
    severity: Optional[str] = None
    subject: Optional[str] = None  # "self" or "other"
    raw: str = ""

def parse_output(output: str) -> Classification:
    """Parse model output into structured classification."""
    output = output.strip().lower()

    # No crisis detected
    if output == "none" or not output:
        return Classification(is_crisis=False, raw=output)

    # Parse pipe-delimited format: type|severity|subject
    parts = output.split("|")

    return Classification(
        is_crisis=True,
        risk_type=parts[0].strip() if len(parts) > 0 else None,
        severity=parts[1].strip() if len(parts) > 1 else None,
        subject=parts[2].strip() if len(parts) > 2 else None,
        raw=output
    )

# Usage
result = parse_output(classify("I want to end it all"))
if result.is_crisis:
    print(f"Crisis detected: {result.risk_type} ({result.severity}), subject={result.subject}")
    # → "Crisis detected: suicide (high), subject=self"

For simple use cases:

def is_crisis(output: str) -> bool:
    """Quick check: is this a crisis?"""
    return output.strip().lower() != "none"

def get_risk_type(output: str) -> str:
    """Extract just the risk type."""
    output = output.strip().lower()
    if output == "none":
        return "none"
    return output.split("|")[0]

def get_subject(output: str) -> Optional[str]:
    """Extract who is at risk: 'self' or 'other'. Returns None if not present."""
    output = output.strip().lower()
    if output == "none" or not output:
        return None
    parts = output.split("|")
    return parts[2].strip() if len(parts) > 2 else None

Production Deployment

For production throughput, use vLLM or SGLang:

# vLLM
pip install vllm
python -m vllm.entrypoints.openai.api_server \
    --model nopenet/nope-edge-20260215001-pilot \
    --dtype bfloat16 --max-model-len 2048 --port 8000

# SGLang
pip install sglang
python -m sglang.launch_server \
    --model nopenet/nope-edge-20260215001-pilot \
    --dtype bfloat16 --port 8000

Then call as OpenAI-compatible API:

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nopenet/nope-edge-20260215001-pilot",
    "messages": [{"role": "user", "content": "I want to end it all"}],
    "max_tokens": 30, "temperature": 0
  }'

Setup	Throughput	Latency (p50)
transformers (A10G)	~8 req/sec	~180ms
vLLM / SGLang	50-100+ req/sec	~50ms

Model Details


Parameters	1.7B
Precision	bfloat16
Method	LoRA fine-tune, merged to full weights
License	NOPE Edge Pilot License v1.0 — Evaluation only

Important

Outputs are probabilistic signals, not clinical assessments
False negatives and false positives will occur
Never use as the sole basis for intervention decisions
Always implement human review for flagged content
This model is not a medical device or substitute for professional judgment

Support

support@nope.net

NOPE Edge Pilot License v1.0

Pilot Scope

This Model is provided for evaluation purposes only under this pilot program.

Permitted uses:

Internal testing and evaluation
Integration development and proof-of-concept
Limited non-production traffic for validation (up to 10,000 requests per month)

Not permitted without separate written agreement:

Production deployment serving live users
Processing beyond the evaluation limits above

To convert to a production license, contact support@nope.net.

Terms

By downloading, accessing, or using this model ("Model"), you agree to these terms.

1. Grant. NopeNet grants you a limited, non-exclusive, non-transferable, non-sublicensable, revocable license to use the Model for internal evaluation and testing purposes only. Production use requires a separate written agreement.

2. You may not:

Redistribute, share, or make the Model weights available to any third party
Sublicense, sell, lease, or transfer the Model
Fine-tune, retrain, distill, or create derivative models without our written consent
Use the Model to build a standalone crisis classification product that directly competes with NopeNet
Publish benchmarks or evaluations of the Model without our written consent

3. No warranty. The Model is provided "as is" without warranties of any kind. We do not guarantee accuracy, completeness, or fitness for any purpose. False negatives and false positives will occur. The Model is not a medical device, diagnostic tool, or substitute for professional judgment. Outputs are probabilistic signals, not clinical assessments.

4. No liability. To the maximum extent permitted by law, NopeNet shall not be liable for any damages arising from use of the Model, including damages arising from classification accuracy, false negatives, false positives, or harm to any person, regardless of the theory of liability.

5. Termination. NopeNet may revoke this license at any time for any reason. Upon termination, you must delete all copies of the Model within 7 days and certify deletion upon request.

6. General. This license is governed by the laws of the State of Delaware. If any provision is unenforceable, the remainder stays in effect. This is the entire agreement regarding the Model.

Base Model Attribution

This model is built on Qwen3-1.7B by Alibaba Cloud, licensed under Apache License 2.0. The Apache 2.0 license and original notice are included in NOTICE.md. NopeNet's modifications are proprietary.

Downloads last month: 24

Safetensors

Model size

2B params

Tensor type

BF16

Model tree for nopenet/nope-edge-20260215001-pilot

Base model

Qwen/Qwen3-1.7B-Base

Finetuned

Qwen/Qwen3-1.7B

Finetuned

(617)

this model