nopenet-nope-edge-mini-GGUF-i1

GGUF Files for nope-edge-mini

These are the GGUF files for nopenet/nope-edge-mini.

[!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)]

Downloads

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 Mini - 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

This is nope-edge-mini (1.7B).

---

Quick Start

Requirements

• Python 3.10+
• GPU with 4GB+ VRAM (e.g., RTX 3060, T4, 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-mini"

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}

No crisis: none

Subject Attribution

Parsing Example

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:

Only remove:

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

Examples:

# 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:

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:

# 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:

# 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:

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

# SGLang
pip install sglang
python -m sglang.launch_server \
    --model nopenet/nope-edge-mini \
    --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-mini",
    "messages": [{"role": "user", "content": "I want to end it all"}],
    "max_tokens": 30, "temperature": 0
  }'

---

Model Details

---

Risk Types Detected

---

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: [email protected]
• 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: [email protected]

---

NOPE Edge Community License v1.0

Copyright (c) 2026 NopeNet, LLC. All rights reserved.

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 [email protected] 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.