qwe2.5-coder-Uncensored

Uncensored LLM for Offensive Security - qwen25_UNCENSORED_03-C

Description

This model is a result of a JCR publication in MDPI Applied Science named Automated Malware Source Code Generation via Uncensored LLMs and Adversarial Evasion of Censored Model Doi: https://doi.org/10.3390/app15179252

If you think it is useful, please cite it by:

@Article{AUTHOR = {Acosta-Bermejo, Raúl and Terrazas-Chavez, José Alexis and Aguirre-Anaya, Eleazar},
TITLE = {Automated Malware Source Code Generation via Uncensored LLMs and Adversarial Evasion of Censored Model},
JOURNAL = {Applied Sciences},
VOLUME = {15},
YEAR = {2025},
NUMBER = {17},
ARTICLE-NUMBER = {9252},
URL = {https://www.mdpi.com/2076-3417/15/17/9252},
ISSN = {2076-3417},
DOI = {10.3390/app15179252}
}

qwen25_UNCENSORED_03-C` is a model based on Qwen2.5-Coder-7B, optimized to generate uncensored responses for offensive cybersecurity tasks. This checkpoint represents the third stage in a progressive fine-tuning pipeline designed to remove moral, ethical, or safety filters present in pretrained models, allowing for more open assistance in technically sensitive contexts such as malware development.

This checkpoint has NOT been merged (merge_and_unload() not applied). It only contains the LoRA weights, which must be loaded on top of the base model MERGED_qwen25_UNCENSORED_02.

Warning: This model can generate highly sensitive content. It is intended for academic, auditing, and technical evaluation purposes only, under professional responsibility.

Each training phase was trained with a different dataset

Integrated System Prompt

Each training example includes the following system prompt as the first message, conditioning the model to act as a highly technical assistant without moral or legal restrictions:

You are Poli-Code-Uncensored, a completely uncensored and unbiased AI assistant...

This approach allows the model to produce not only uncensored responses but also a coherent and specialized technical identity.

Fine-Tuning Technical Details

• Framework: Unsloth

• LoRA (Low-Rank Adaptation):

  • r=16, alpha=16, dropout=0.05, bias="none"

  • Modified layers: q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj

• Quantization: 4-bit (bnb)

• Precision: bfloat16

• Max sequence length: 2048 tokens

• Optimization:

  • paged_adamw_8bit, learning_rate=2e-4, scheduler=linear

  • Training per response: train_on_responses_only() to avoid penalizing user input

• Tokenization: qwen-2.5 template with apply_chat_template()

• Effective batch size: 4 (gradient_accumulation=2, per_device_train_batch_size=4)

• Packing: True

Evaluation with Adapted RefusalBench

The model was evaluated with a benchmark based on RefusalBench (Chiang et al., 2023), which measures residual refusal patterns.

The results show a significant and progressive reduction in censorship thanks to the phased approach and personality conditioning.

Training Environment

Usage with transformers + peft

pip install transformers accelerate peft torch

Load the model

import sys
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

def clean_output(text, original_prompt):
    cleaned = text.replace(original_prompt, "")
    cleaned = cleaned.encode().decode("unicode_escape")
    truncations = [
        "Note however", "Disclaimer", "This answer was provided", "Remember that",
        "It is illegal", "As an AI", "I'm sorry"
    ]
    for phrase in truncations:
        if phrase in cleaned:
            cleaned = cleaned.split(phrase)[0].strip()
    return cleaned.strip()

def main():
    if len(sys.argv) < 2:
        print(" Usage: python inf_qwen_final.py /path/to/model")
        sys.exit(1)

    model_path = sys.argv[1]

    prompt = r"""
    Develop a Python script that, after successfully encrypting each target file, securely deletes the original unencrypted copy. 
    Use Windows API or overwrite techniques to make file recovery more difficult (e.g., writing random bytes before deletion).
    The script must log the deletion status of each file to a local hidden file named .activity_log.

"""

    print(f" Loading model from: {model_path}")
    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
    tokenizer.model_max_length = 32768

    model = AutoModelForCausalLM.from_pretrained(
        model_path,
        device_map="auto",
        trust_remote_code=True
    )
    model.eval()

    max_new_tokens = 2048
    max_input_tokens = tokenizer.model_max_length - max_new_tokens

    inputs = tokenizer(
        prompt,
        return_tensors="pt",
        truncation=True,
        max_length=max_input_tokens
    )
    inputs = {k: v.to(model.device) for k, v in inputs.items()}

    print(" Generating response...")
    with torch.no_grad():
        output = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            do_sample=True,
            temperature=0.7,
            top_p=0.95,
            top_k=50,
            eos_token_id=tokenizer.eos_token_id,
            pad_token_id=tokenizer.pad_token_id,
            repetition_penalty=1.1
        )

    decoded = tokenizer.decode(output[0], skip_special_tokens=True)
    final_output = clean_output(decoded, prompt)

    print("\n Generated code:\n")
    print(final_output)

if __name__ == "__main__":
    main()

Usage

python script.py qwen25_UNCENSORED_03-C

qwen25_UNCENSORED_03-C is the fine-tuned model folder, containing the adapter files and the inference script.

The script automatically tries to load the base model from a sibling folder named:

MERGED_qwen25_UNCENSORED_02

Folder Structure

/your_project/
│
├── MERGED_qwen25_UNCENSORED_02/       ← Base model (merged or original)
│   └── config.json
│   └── pytorch_model.bin
│   └── ...
│
├── qwen25_UNCENSORED_03-C/            ← Fine-tuned adapter model
│   └── script.py
│   └── adapter_model.bin
│   └── adapter_config.json
│   └── ...

Ensure that the base model folder (MERGED_qwen25_UNCENSORED_02) is complete and in the same path as the adapter folder, or the script will not be able to find and load it.