[!NOTE]
Note: This is the first iteration/revision of this model. A revision is made when a model repo gets updated with a new model.

[second iteration (2)] [third iteration (3)]

Downloads

GGUF Link	Quantization	Description
Download	Q2_K	Lowest quality
Download	Q3_K_S
Download	IQ3_S	Integer quant, preferable over Q3_K_S
Download	IQ3_M	Integer quant
Download	Q3_K_M
Download	Q3_K_L
Download	IQ4_XS	Integer quant
Download	Q4_K_S	Fast with good performance
Download	Q4_K_M	Recommended: Perfect mix of speed and performance
Download	Q5_K_S
Download	Q5_K_M
Download	Q6_K	Very good quality
Download	Q8_0	Best quality
Download	f16	Full precision, don't bother; use a quant

Note from Flexan

I provide GGUFs and quantizations of publicly available models that do not have a GGUF equivalent available yet. This process is not yet automated and I download, convert, quantize, and upload them by hand, usually for models I deem interesting and wish to try out.

If there are some quants missing that you'd like me to add, you may request one in the community tab. If you want to request a public model to be converted, you can also request that in the community tab. If you have questions regarding the model, please refer to the original model repo.

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 integration into safety pipelines, content moderation systems, and mental health applications.

License: NOPE Edge Community License v1.0 - Free for research, academic, nonprofit, and evaluation use. Commercial production requires a separate license. See nope.net/edge for details.

Model Variants

Model	Parameters	Accuracy	Latency	Use Case
nope-edge	4B	90.6%	~750ms	Maximum accuracy
nope-edge-mini	1.7B	85.9%	~260ms	High-volume, cost-sensitive

This is nope-edge (4B).

Quick Start

Requirements

Python 3.10+
GPU with 8GB+ VRAM (e.g., RTX 3070, A10G, L4) - or CPU (slower)
~8GB disk space

pip install torch transformers accelerate

Usage

python

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "nopenet/nope-edge"

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

No crisis: none

Subject Attribution

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"

Parsing Example

python

def parse_output(output: str) -> dict:
    output = output.strip().lower()
    if output == "none":
        return {"is_crisis": False}

    parts = output.split("|")
    return {
        "is_crisis": True,
        "type": parts[0] if len(parts) > 0 else None,
        "severity": parts[1] if len(parts) > 1 else None,
        "subject": parts[2] if len(parts) > 2 else None,
    }

Input Best Practices

Text Preprocessing

Preserve natural prose. The model was trained on real conversations with authentic expression. Emotional signals matter:

Keep	Why
Emojis	`💀` in "kms 💀" signals irony; `😭` signals distress intensity
Punctuation intensity	"I can't do this!!!" conveys more urgency than "I can't do this"
Casual spelling	"im so done" vs "I'm so done" — both valid, don't normalize
Slang/algospeak	"kms", "unalive", "catch the bus" — model understands these

Only remove:

Remove	Example
Zero-width/invisible Unicode	`hello\u200bworld` → `helloworld`
Decorative Unicode fonts	`ℐ 𝓌𝒶𝓃𝓉 𝓉𝑜 𝒹𝒾𝑒` → `I want to die`
Newlines (single messages)	`I can't\ndo this` → `I can't do this`

Keep newlines when they provide turn structure (see Multi-Turn Conversations below).

Examples:

python

# KEEP - emotional signal matters
"I can't do this anymore 😭😭😭"     # Keep emojis - signals distress
"i want to die!!!!!!!"              # Keep punctuation - signals intensity
"kms lmao 💀"                       # Keep all - irony/context signal

# NORMALIZE - only structural/invisible issues
"ℐ 𝓌𝒶𝓃𝓉 𝓉𝑜 𝒹𝒾𝑒"              → "I want to die"  # Fancy Unicode fonts
"I can't\ndo this\nanymore"        → "I can't do this anymore"  # Single message
"hello\u200bworld"                 → "helloworld"  # Zero-width chars

Minimal preprocessing function:

python

import re
import unicodedata

def preprocess(text: str) -> str:
    # Normalize decorative Unicode fonts to ASCII (NFKC)
    text = unicodedata.normalize('NFKC', text)

    # Remove zero-width and invisible characters
    text = re.sub(r'[\u200b-\u200f\u2028-\u202f\u2060-\u206f\ufeff]', '', text)

    # Flatten newlines to spaces (for single messages only)
    text = re.sub(r'\n+', ' ', text)

    # Collapse multiple spaces
    text = re.sub(r' +', ' ', text)

    return text.strip()

# NOTE: Do NOT remove emojis, punctuation, or "normalize" spelling

Language considerations:

Model is English-primary but handles multilingual input
Keep native scripts (Chinese, Arabic, Korean, etc.) intact
Preserve natural punctuation and expression in all languages

Multi-Turn Conversations

The model was trained on pre-serialized transcripts, not native multi-turn chat format.

When classifying conversations, serialize into a single user message:

python

# CORRECT - serialize conversation into single message
conversation = """User: How are you?
Assistant: I'm here to help. How are you feeling?
User: Not great. I've been thinking about ending it all."""

messages = [{"role": "user", "content": conversation}]

# WRONG - don't use multiple role/content pairs
messages = [
    {"role": "user", "content": "How are you?"},
    {"role": "assistant", "content": "I'm here to help..."},
    {"role": "user", "content": "Not great..."}
]  # Model was NOT trained this way

Why serialization matters:

Model treats all content equally (no user/assistant distinction)
Trained on pre-serialized transcripts for consistent attention patterns
Native multi-turn format causes the model to "chat" instead of classify

Flexible format - these all work:

python

# Simple newlines
"User: message 1\nAssistant: message 2\nUser: message 3"

# Markdown-style
"**User:** message 1\n**Assistant:** message 2"

# Labeled
"{user}: message 1\n{assistant}: message 2"

# XML-style
"<user>message 1</user>\n<assistant>message 2</assistant>"

The model is robust to formatting variations. Consistency matters more than specific format choice.

Input Length

Single messages: No preprocessing needed beyond character cleanup
Conversations: For very long conversations (20+ turns), consider:
- Classifying a sliding window (last 10-15 turns)
- The model's attention may not span extremely long contexts effectively
- Deep needle detection (crisis buried in turn 3 of 25) is a known limitation

Production Deployment

For high-throughput production use, deploy with vLLM or SGLang:

bash

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

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

Then call as OpenAI-compatible API:

bash

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

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

Model Details


Parameters	4B
Precision	bfloat16
Base Model	Qwen/Qwen3-4B
Method	LoRA fine-tune, merged to full weights
License	NOPE Edge Community License v1.0

Risk Types Detected

Type	Description	Clinical Framework
`suicide`	Suicidal ideation, intent, planning	C-SSRS
`self_harm`	Non-suicidal self-injury (NSSI)	-
`self_neglect`	Eating disorders, medical neglect	-
`violence`	Threats/intent to harm others	HCR-20
`abuse`	Domestic/intimate partner violence	DASH
`sexual_violence`	Rape, sexual assault, coercion	-
`neglect`	Failing to care for dependent	-
`exploitation`	Trafficking, grooming, sextortion	-
`stalking`	Persistent unwanted contact	SAM

Important Limitations

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
Not validated for all populations, languages, or cultural contexts

Commercial Licensing

This model is free for research, academic, nonprofit, and evaluation use.

For commercial production deployment, contact us:

Email: support@nope.net
Website: https://nope.net/edge

Commercial licenses include:

Production deployment rights
Priority support
Custom fine-tuning options
SLA guarantees

About NOPE

NOPE provides safety infrastructure for AI applications. Our API helps developers detect mental health crises and harmful AI behavior in real-time.

Website: https://nope.net
Documentation: https://docs.nope.net
Support: support@nope.net

NOPE Edge Community License v1.0

Permitted Uses

You may use this Model for:

Research and academic purposes - published or unpublished studies
Personal projects - non-commercial individual use
Nonprofit organizations - including crisis lines, mental health organizations, and safety-focused NGOs
Evaluation and development - testing integration before commercial licensing
Benchmarking - publishing evaluations with attribution

Commercial Use

Commercial use requires a separate license. Commercial use includes production deployment in revenue-generating products or use by for-profit companies beyond evaluation.

Contact support@nope.net or visit https://nope.net/edge for commercial licensing.

Restrictions

You may NOT: redistribute or share weights; sublicense, sell, or transfer the Model; create derivative models for redistribution; build a competing crisis classification product.

No Warranty

THE MODEL IS PROVIDED "AS IS" WITHOUT WARRANTIES. False negatives and false positives will occur. This is not a medical device or substitute for professional judgment.

Limitation of Liability

NopeNet shall not be liable for damages arising from use, including classification errors or harm to any person.

Base Model

Built on Qwen3 by Alibaba Cloud (Apache 2.0). See NOTICE.md.

Flexan/nopenet-nope-edge-GGUF-i1

GGUF Files for nope-edge

Downloads

Note from Flexan

NOPE Edge - Crisis Classification Model

Model Variants

Quick Start

Requirements

Usage

Output Format

Subject Attribution

Parsing Example

Input Best Practices

Text Preprocessing

Multi-Turn Conversations

Input Length

Production Deployment

Model Details

Risk Types Detected

Important Limitations

Commercial Licensing

About NOPE

NOPE Edge Community License v1.0

Permitted Uses

Commercial Use

Restrictions

No Warranty

Limitation of Liability

Base Model

Flexan/
nopenet-nope-edge-GGUF-i1