Add inference optimization and training scripts for Qwen3.5-0.8B-HOS

configs/train.yaml

@@ -0,0 +1,59 @@
+### Qwen3.5-0.8B-HOS QLoRA 训练配置 (针对 0.8B 小模型优化)
+
+### 模型配置
+model_name_or_path: lxcxjxhx/Qwen3.5-0.8B-HOS
+trust_remote_code: true
+
+### 训练方法
+stage: sft
+do_train: true
+finetuning_type: lora
+
+### 数据集配置
+dataset: merged_cybersec
+dataset_dir: datasets
+template: qwen
+cutoff_len: 2048  # 0.8B 模型可以使用更长的序列
+overwrite_cache: true
+preprocessing_num_workers: 8
+
+### QLoRA 量化配置 (4-bit NF4)
+quantization_bit: 4
+quantization_method: bitsandbytes
+bnb_4bit_quant_type: nf4
+bnb_4bit_use_double_quant: true
+bnb_4bit_compute_dtype: bfloat16
+
+### LoRA 配置 (0.8B 模型优化)
+lora_rank: 16  # 针对小模型降低 rank
+lora_alpha: 32  # alpha = 2 * rank
+lora_dropout: 0.05
+lora_target: all
+
+### 训练参数 (0.8B 模型优化，显存需求更低)
+per_device_train_batch_size: 4  # 0.8B 模型可以使用更大的 batch_size
+gradient_accumulation_steps: 4  # 累积 4 步，等效 batch_size = 16
+learning_rate: 2e-5  # 指定的学习率
+num_train_epochs: 3
+lr_scheduler_type: cosine
+warmup_ratio: 0.1
+max_grad_norm: 1.0
+logging_steps: 10
+save_steps: 200
+save_total_limit: 3
+overwrite_output_dir: true
+
+### 输出配置
+output_dir: outputs/qwen35-0.8b-cybersec-qlora
+
+### 精度配置
+bf16: true
+
+### 性能优化
+gradient_checkpointing: true  # 启用梯度检查点，节省显存
+optim: adamw_torch_fused  # 使用融合优化器
+
+### HuggingFace Hub 配置
+push_to_hub: true
+hub_model_id: lxcxjxhx/Qwen3.5-0.8B-HOS
+hub_strategy: every_save

datasets/dataset_info.json

@@ -0,0 +1,38 @@
+{
+  "cybersecurity_hq": {
+    "file_name": "cybersecurity_hq.jsonl",
+    "formatting": "alpaca",
+    "columns": {
+      "prompt": "instruction",
+      "query": "input",
+      "response": "output"
+    }
+  },
+  "cybersecurity_sharegpt": {
+    "file_name": "cybersecurity_sharegpt.jsonl",
+    "formatting": "alpaca",
+    "columns": {
+      "prompt": "instruction",
+      "query": "input",
+      "response": "output"
+    }
+  },
+  "cnvd_vulnerability": {
+    "file_name": "cnvd_vulnerability.jsonl",
+    "formatting": "alpaca",
+    "columns": {
+      "prompt": "instruction",
+      "query": "input",
+      "response": "output"
+    }
+  },
+  "merged_cybersec": {
+    "file_name": "merged_cybersec.jsonl",
+    "formatting": "alpaca",
+    "columns": {
+      "prompt": "instruction",
+      "query": "input",
+      "response": "output"
+    }
+  }
+}

inference/benchmark.py

@@ -0,0 +1,396 @@
+#!/usr/bin/env python3
+"""
+Qwen3.5-0.8B-HOS 推理性能基准测试脚本
+
+测试指标：
+- 吞吐量 (tokens/sec)
+- 首token延迟 (Time to First Token, TTFT)
+- 每token生成时间 (Time Per Output Token, TPOT)
+- 显存占用
+- 不同batch size和sequence length下的性能
+
+使用方法：
+  python benchmark.py
+
+可选参数：
+  --model: 模型路径或HF仓库ID
+  --backend: 推理后端 (transformers, vllm, sglang)
+  --batch-sizes: 测试的batch size列表，如 "1,2,4,8"
+  --seq-lengths: 测试的序列长度列表，如 "128,256,512,1024"
+  --output-len: 生成的token数量
+  --output: 结果保存路径
+"""
+
+import argparse
+import json
+import time
+import os
+from typing import List, Dict, Any
+import torch
+
+
+def get_gpu_memory():
+    """获取GPU显存使用情况"""
+    if torch.cuda.is_available():
+        allocated = torch.cuda.memory_allocated() / 1024**3
+        reserved = torch.cuda.memory_reserved() / 1024**3
+        return {"allocated_gb": allocated, "reserved_gb": reserved}
+    return {"allocated_gb": 0, "reserved_gb": 0}
+
+
+def benchmark_transformers(model_path: str, batch_sizes: List[int],
+                          seq_lengths: List[int], output_len: int = 128) -> List[Dict[str, Any]]:
+    """使用HuggingFace Transformers进行基准测试"""
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    print(f"\n{'='*60}")
+    print(f"使用 Transformers 后端测试模型: {model_path}")
+    print(f"{'='*60}")
+
+    # 加载模型和分词器
+    print("加载模型...")
+    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        model_path,
+        torch_dtype=torch.float16,
+        device_map="auto",
+        trust_remote_code=True
+    )
+    model.eval()
+
+    results = []
+
+    for batch_size in batch_sizes:
+        for seq_length in seq_lengths:
+            print(f"\n测试 batch_size={batch_size}, seq_length={seq_length}...")
+
+            # 准备输入
+            input_text = "信息安全是保护计算机系统" * (seq_length // 10)
+            inputs = tokenizer(input_text, return_tensors="pt", max_length=seq_length, truncation=True)
+            input_ids = inputs["input_ids"].to(model.device)
+
+            # 扩展为batch
+            input_ids = input_ids.repeat(batch_size, 1)
+
+            # 清空GPU缓存
+            torch.cuda.empty_cache()
+            torch.cuda.reset_peak_memory_stats()
+
+            # 预热
+            with torch.no_grad():
+                _ = model.generate(input_ids, max_new_tokens=10, do_sample=False)
+
+            # 测试首token延迟
+            torch.cuda.synchronize()
+            start_time = time.time()
+
+            with torch.no_grad():
+                outputs = model.generate(
+                    input_ids,
+                    max_new_tokens=output_len,
+                    do_sample=False,
+                    temperature=1.0,
+                    use_cache=True
+                )
+
+            torch.cuda.synchronize()
+            total_time = time.time() - start_time
+
+            # 计算指标
+            generated_tokens = outputs.shape[1] - input_ids.shape[1]
+            total_tokens = generated_tokens * batch_size
+            throughput = total_tokens / total_time
+
+            # 估算TTFT（使用第一次生成的时间）
+            ttft = total_time / (generated_tokens + 1) * 1000  # 转换为毫秒
+
+            # 计算TPOT
+            tpot = (total_time * 1000) / generated_tokens  # 转换为毫秒
+
+            # 获取显存使用
+            memory = get_gpu_memory()
+
+            result = {
+                "backend": "transformers",
+                "batch_size": batch_size,
+                "seq_length": seq_length,
+                "output_length": output_len,
+                "generated_tokens": generated_tokens,
+                "total_time_sec": total_time,
+                "throughput_tokens_per_sec": throughput,
+                "ttft_ms": ttft,
+                "tpot_ms": tpot,
+                "memory_allocated_gb": memory["allocated_gb"],
+                "memory_reserved_gb": memory["reserved_gb"],
+            }
+
+            results.append(result)
+
+            print(f"  吞吐量: {throughput:.2f} tokens/sec")
+            print(f"  TTFT: {ttft:.2f} ms")
+            print(f"  TPOT: {tpot:.2f} ms")
+            print(f"  显存占用: {memory['allocated_gb']:.2f} GB")
+
+    # 释放模型
+    del model, tokenizer
+    torch.cuda.empty_cache()
+
+    return results
+
+
+def benchmark_vllm(model_path: str, batch_sizes: List[int],
+                   seq_lengths: List[int], output_len: int = 128) -> List[Dict[str, Any]]:
+    """使用vLLM进行基准测试"""
+    try:
+        from vllm import LLM, SamplingParams
+    except ImportError:
+        print("错误: 未安装vLLM，请运行: pip install vllm")
+        return []
+
+    print(f"\n{'='*60}")
+    print(f"使用 vLLM 后端测试模型: {model_path}")
+    print(f"{'='*60}")
+
+    # 初始化vLLM引擎
+    print("初始化vLLM引擎...")
+    llm = LLM(
+        model=model_path,
+        dtype="float16",
+        trust_remote_code=True,
+        max_model_len=2048,
+        gpu_memory_utilization=0.9
+    )
+
+    results = []
+
+    for batch_size in batch_sizes:
+        for seq_length in seq_lengths:
+            print(f"\n测试 batch_size={batch_size}, seq_length={seq_length}...")
+
+            # 准备输入
+            input_text = "信息安全是保护计算机系统" * (seq_length // 10)
+            prompts = [input_text] * batch_size
+
+            # 采样参数
+            sampling_params = SamplingParams(
+                temperature=1.0,
+                max_tokens=output_len,
+                use_beam_search=False
+            )
+
+            # 清空GPU缓存
+            torch.cuda.empty_cache()
+            torch.cuda.reset_peak_memory_stats()
+
+            # 测试
+            torch.cuda.synchronize()
+            start_time = time.time()
+
+            outputs = llm.generate(prompts, sampling_params)
+
+            torch.cuda.synchronize()
+            total_time = time.time() - start_time
+
+            # 计算指标
+            generated_tokens = sum(len(output.outputs[0].token_ids) for output in outputs)
+            total_tokens = generated_tokens
+            throughput = total_tokens / total_time
+
+            # 估算TTFT和TPOT
+            ttft = total_time / (generated_tokens / batch_size + 1) * 1000
+            tpot = (total_time * 1000) / (generated_tokens / batch_size)
+
+            # 获取显存使用
+            memory = get_gpu_memory()
+
+            result = {
+                "backend": "vllm",
+                "batch_size": batch_size,
+                "seq_length": seq_length,
+                "output_length": output_len,
+                "generated_tokens": generated_tokens,
+                "total_time_sec": total_time,
+                "throughput_tokens_per_sec": throughput,
+                "ttft_ms": ttft,
+                "tpot_ms": tpot,
+                "memory_allocated_gb": memory["allocated_gb"],
+                "memory_reserved_gb": memory["reserved_gb"],
+            }
+
+            results.append(result)
+
+            print(f"  吞吐量: {throughput:.2f} tokens/sec")
+            print(f"  TTFT: {ttft:.2f} ms")
+            print(f"  TPOT: {tpot:.2f} ms")
+            print(f"  显存占用: {memory['allocated_gb']:.2f} GB")
+
+    return results
+
+
+def benchmark_sglang(model_path: str, batch_sizes: List[int],
+                     seq_lengths: List[int], output_len: int = 128) -> List[Dict[str, Any]]:
+    """使用SGLang进行基准测试"""
+    try:
+        import sglang as sgl
+    except ImportError:
+        print("错误: 未安装SGLang，请运行: pip install sglang")
+        return []
+
+    print(f"\n{'='*60}")
+    print(f"使用 SGLang 后端测试模型: {model_path}")
+    print(f"{'='*60}")
+
+    # 初始化SGLang运行时
+    print("初始化SGLang运行时...")
+    runtime = sgl.Runtime(
+        model_path=model_path,
+        trust_remote_code=True,
+        context_length=2048,
+    )
+    sgl.set_default_backend(runtime)
+
+    results = []
+
+    for batch_size in batch_sizes:
+        for seq_length in seq_lengths:
+            print(f"\n测试 batch_size={batch_size}, seq_length={seq_length}...")
+
+            # 准备输入
+            input_text = "信息安全是保护计算机系统" * (seq_length // 10)
+            prompts = [input_text] * batch_size
+
+            # 清空GPU缓存
+            torch.cuda.empty_cache()
+            torch.cuda.reset_peak_memory_stats()
+
+            # 测试
+            torch.cuda.synchronize()
+            start_time = time.time()
+
+            @sgl.function
+            def generate_text(s, prompt):
+                s += prompt + sgl.gen("response", max_tokens=output_len, temperature=1.0)
+
+            states = [generate_text.run(prompt=p) for p in prompts]
+
+            torch.cuda.synchronize()
+            total_time = time.time() - start_time
+
+            # 计算指标
+            generated_tokens = sum(len(state["response"]) for state in states) // 2  # 粗略估算
+            total_tokens = generated_tokens
+            throughput = total_tokens / total_time
+
+            # 估算TTFT和TPOT
+            ttft = total_time / (generated_tokens / batch_size + 1) * 1000
+            tpot = (total_time * 1000) / (generated_tokens / batch_size)
+
+            # 获取显存使用
+            memory = get_gpu_memory()
+
+            result = {
+                "backend": "sglang",
+                "batch_size": batch_size,
+                "seq_length": seq_length,
+                "output_length": output_len,
+                "generated_tokens": generated_tokens,
+                "total_time_sec": total_time,
+                "throughput_tokens_per_sec": throughput,
+                "ttft_ms": ttft,
+                "tpot_ms": tpot,
+                "memory_allocated_gb": memory["allocated_gb"],
+                "memory_reserved_gb": memory["reserved_gb"],
+            }
+
+            results.append(result)
+
+            print(f"  吞吐量: {throughput:.2f} tokens/sec")
+            print(f"  TTFT: {ttft:.2f} ms")
+            print(f"  TPOT: {tpot:.2f} ms")
+            print(f"  显存占用: {memory['allocated_gb']:.2f} GB")
+
+    runtime.shutdown()
+
+    return results
+
+
+def print_summary(results: List[Dict[str, Any]]):
+    """打印测试结果汇总"""
+    if not results:
+        print("\n没有测试结果可汇总")
+        return
+
+    print(f"\n{'='*80}")
+    print("基准测试结果汇总")
+    print(f"{'='*80}")
+    print(f"{'Backend':<12} {'Batch':<6} {'SeqLen':<7} {'OutLen':<7} "
+          f"{'Throughput':<12} {'TTFT(ms)':<10} {'TPOT(ms)':<10} {'Memory(GB)':<11}")
+    print(f"{'-'*80}")
+
+    for r in results:
+        print(f"{r['backend']:<12} {r['batch_size']:<6} {r['seq_length']:<7} "
+              f"{r['output_length']:<7} {r['throughput_tokens_per_sec']:<12.2f} "
+              f"{r['ttft_ms']:<10.2f} {r['tpot_ms']:<10.2f} {r['memory_allocated_gb']:<11.2f}")
+    
+    print(f"{'='*80}\n")
+
+
+def main():
+    """主函数"""
+    parser = argparse.ArgumentParser(description="Qwen3.5-0.8B-HOS 推理性能基准测试")
+    parser.add_argument("--model", type=str, default="lxcxjxhx/Qwen3.5-0.8B-HOS",
+                       help="模型路径或HF仓库ID")
+    parser.add_argument("--backend", type=str, default="transformers",
+                       choices=["transformers", "vllm", "sglang"],
+                       help="推理后端")
+    parser.add_argument("--batch-sizes", type=str, default="1,2,4,8",
+                       help="测试的batch size列表，如 '1,2,4,8'")
+    parser.add_argument("--seq-lengths", type=str, default="128,256,512,1024",
+                       help="测试的序列长度列表，如 '128,256,512,1024'")
+    parser.add_argument("--output-len", type=int, default=128,
+                       help="生成的token数量")
+    parser.add_argument("--output", type=str, default="benchmark_results.json",
+                       help="结果保存路径")
+    
+    args = parser.parse_args()
+    
+    # 解析列表参数
+    batch_sizes = [int(x) for x in args.batch_sizes.split(",")]
+    seq_lengths = [int(x) for x in args.seq_lengths.split(",")]
+    
+    print(f"\n{'='*60}")
+    print(f"Qwen3.5-0.8B-HOS 推理性能基准测试")
+    print(f"{'='*60}")
+    print(f"模型: {args.model}")
+    print(f"后端: {args.backend}")
+    print(f"Batch sizes: {batch_sizes}")
+    print(f"Sequence lengths: {seq_lengths}")
+    print(f"Output length: {args.output_len}")
+    print(f"{'='*60}\n")
+    
+    # 执行基准测试
+    if args.backend == "transformers":
+        results = benchmark_transformers(
+            args.model, batch_sizes, seq_lengths, args.output_len
+        )
+    elif args.backend == "vllm":
+        results = benchmark_vllm(
+            args.model, batch_sizes, seq_lengths, args.output_len
+        )
+    elif args.backend == "sglang":
+        results = benchmark_sglang(
+            args.model, batch_sizes, seq_lengths, args.output_len
+        )
+    
+    # 打印汇总
+    print_summary(results)
+    
+    # 保存结果
+    if results:
+        with open(args.output, 'w', encoding='utf-8') as f:
+            json.dump(results, f, indent=2, ensure_ascii=False)
+        print(f"结果已保存到: {args.output}")
+
+
+if __name__ == "__main__":
+    main()

inference/quantize.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python3
+"""
+Qwen3.5-0.8B-HOS 量化脚本
+
+支持量化方法：
+- AWQ 4-bit：激活感知量化，精度损失最小
+- GPTQ 8-bit：基于 GPU 的 Post-Training 量化
+- bitsandbytes 4/8-bit：动态量化，无需校准数据
+
+使用方法：
+  # AWQ 4-bit 量化
+  python quantize.py --method awq --bits 4
+
+  # GPTQ 8-bit 量化
+  python quantize.py --method gptq --bits 8
+
+  # bitsandbytes 4-bit 动态量化（最简单，无需校准数据）
+  python quantize.py --method bnb --bits 4
+
+  # 测试量化后模型
+  python quantize.py --method awq --bits 4 --test
+"""
+
+import argparse
+import os
+import time
+import torch
+
+
+def quantize_awq(model_path, output_path, bits=4):
+    """AWQ 4-bit 量化
+
+    AWQ (Activation-aware Weight Quantization) 通过保护显著权重通道
+    实现高精度 4-bit 量化，适合 0.8B 小模型。
+    """
+    print(f"=== AWQ {bits}-bit 量化 ===")
+    print(f"输入模型: {model_path}")
+    print(f"输出路径: {output_path}")
+
+    try:
+        from awq import AutoAWQForCausalLM
+        from transformers import AutoTokenizer
+
+        # 加载模型和分词器
+        print("加载模型...")
+        model = AutoAWQForCausalLM.from_pretrained(
+            model_path,
+            trust_remote_code=True,
+        )
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_path,
+            trust_remote_code=True,
+        )
+
+        # AWQ 量化配置
+        quant_config = {
+            "zero_point": True,
+            "q_group_size": 128,
+            "w_bit": bits,
+            "version": "GEMM",
+        }
+
+        print(f"开始 AWQ {bits}-bit 量化...")
+        model.quantize(tokenizer, quant_config=quant_config)
+
+        # 保存量化模型
+        print(f"保存量化模型到: {output_path}")
+        model.save_quantized(output_path)
+        tokenizer.save_pretrained(output_path)
+
+        print("AWQ 量化完成！")
+        return output_path
+
+    except ImportError:
+        print("错误: 需要安装 autoawq")
+        print("  pip install autoawq")
+        return None
+
+
+def quantize_gptq(model_path, output_path, bits=8):
+    """GPTQ 量化
+
+    GPTQ 基于 Optimal Brain Quantization 框架，通过逐层量化
+    和误差补偿实现高精度量化。
+    """
+    print(f"=== GPTQ {bits}-bit 量化 ===")
+    print(f"输入模型: {model_path}")
+    print(f"输出路径: {output_path}")
+
+    try:
+        from transformers import AutoTokenizer
+        from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
+
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_path,
+            trust_remote_code=True,
+        )
+
+        # GPTQ 量化配置
+        quantize_config = BaseQuantizeConfig(
+            bits=bits,
+            group_size=128,
+            desc_act=False,
+            damp_percent=0.1,
+        )
+
+        print("加载模型...")
+        model = AutoGPTQForCausalLM.from_pretrained(
+            model_path,
+            quantize_config,
+            trust_remote_code=True,
+        )
+
+        # 准备校准数据（使用简单文本）
+        print("准备校准数据...")
+        calibration_texts = [
+            "信息安全是保护计算机系统和网络免受未经授权的访问、攻击或破坏的实践。",
+            "SQL注入是一种常见的Web安全漏洞，攻击者通过注入恶意SQL代码来操纵数据库。",
+            "渗透测试是一种模拟真实攻击者的方法来评估系统安全性的技术。",
+            "防火墙是网络安全的第一道防线，用于监控和控制进出网络的流量。",
+        ]
+
+        calibration_data = [
+            tokenizer(text, return_tensors="pt", max_length=512, truncation=True)
+            for text in calibration_texts
+        ]
+
+        print(f"开始 GPTQ {bits}-bit 量化...")
+        model.quantize(calibration_data)
+
+        print(f"保存量化模型到: {output_path}")
+        model.save_quantized(output_path)
+        tokenizer.save_pretrained(output_path)
+
+        print("GPTQ 量化完成！")
+        return output_path
+
+    except ImportError:
+        print("错误: 需要安装 auto-gptq")
+        print("  pip install auto-gptq")
+        return None
+
+
+def quantize_bnb(model_path, output_path, bits=4):
+    """bitsandbytes 动态量化
+
+    最简单的量化方法，无需校准数据，适合快速部署。
+    支持 4-bit (NF4/FP4) 和 8-bit 量化。
+    """
+    print(f"=== bitsandbytes {bits}-bit 量化 ===")
+    print(f"输入模型: {model_path}")
+    print(f"输出路径: {output_path}")
+
+    from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+
+    if bits == 4:
+        quant_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_compute_dtype=torch.bfloat16,
+        )
+    elif bits == 8:
+        quant_config = BitsAndBytesConfig(
+            load_in_8bit=True,
+        )
+    else:
+        raise ValueError(f"不支持的量化位数: {bits}")
+
+    print("加载并量化模型...")
+    model = AutoModelForCausalLM.from_pretrained(
+        model_path,
+        quantization_config=quant_config,
+        trust_remote_code=True,
+        device_map="auto",
+    )
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_path,
+        trust_remote_code=True,
+    )
+
+    # 保存量化后的模型
+    os.makedirs(output_path, exist_ok=True)
+    print(f"保存量化模型到: {output_path}")
+    model.save_pretrained(output_path)
+    tokenizer.save_pretrained(output_path)
+
+    print(f"bitsandbytes {bits}-bit 量化完成！")
+    return output_path
+
+
+def test_quantized_model(model_path, bits=4):
+    """测试量化后模型的推理"""
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    print(f"\n=== 测试量化模型 ===")
+    print(f"模型路径: {model_path}")
+
+    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+
+    # 根据量化方法选择加载方式
+    if "awq" in model_path.lower() or "gptq" in model_path.lower():
+        model = AutoModelForCausalLM.from_pretrained(
+            model_path,
+            trust_remote_code=True,
+            device_map="auto",
+        )
+    else:
+        # bitsandbytes 量化模型
+        quant_config = BitsAndBytesConfig(
+            load_in_4bit=(bits == 4),
+            load_in_8bit=(bits == 8),
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_use_double_quant=True,
+            bnb_4bit_compute_dtype=torch.bfloat16,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            model_path,
+            quantization_config=quant_config,
+            trust_remote_code=True,
+            device_map="auto",
+        )
+
+    # 测试推理
+    test_prompts = [
+        "什么是DDoS攻击？",
+        "如何防范中间人攻击？",
+    ]
+
+    for prompt in test_prompts:
+        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+
+        start = time.time()
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_new_tokens=128,
+                temperature=0.7,
+                top_p=0.9,
+            )
+        elapsed = time.time() - start
+
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        token_count = outputs.shape[1] - inputs["input_ids"].shape[1]
+
+        print(f"\nPrompt: {prompt}")
+        print(f"回复: {response[:200]}...")
+        print(f"生成 {token_count} tokens, 耗时 {elapsed:.2f}s")
+
+
+def get_model_size(model_path):
+    """获取模型文件大小"""
+    total_size = 0
+    for dirpath, _, filenames in os.walk(model_path):
+        for f in filenames:
+            if f.endswith((".safetensors", ".bin", ".pt")):
+                fp = os.path.join(dirpath, f)
+                total_size += os.path.getsize(fp)
+    return total_size / (1024 ** 3)  # GB
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Qwen3.5-0.8B-HOS 量化脚本")
+    parser.add_argument("--model", type=str, default="lxcxjxhx/Qwen3.5-0.8B-HOS",
+                        help="输入模型路径")
+    parser.add_argument("--output", type=str, default=None,
+                        help="输出模型路径")
+    parser.add_argument("--method", type=str, default="bnb",
+                        choices=["awq", "gptq", "bnb"],
+                        help="量化方法")
+    parser.add_argument("--bits", type=int, default=4, choices=[4, 8],
+                        help="量化位数")
+    parser.add_argument("--test", action="store_true",
+                        help="测试量化后模型")
+
+    args = parser.parse_args()
+
+    if args.output is None:
+        args.output = f"{args.model.replace('/', '-')}-{args.method}-{args.bits}bit"
+
+    print(f"量化方法: {args.method}")
+    print(f"量化位数: {args.bits}-bit")
+
+    # 量化前模型大小
+    if os.path.exists(args.model):
+        original_size = get_model_size(args.model)
+        print(f"原始模型大小: {original_size:.2f} GB")
+
+    # 执行量化
+    if args.method == "awq":
+        result = quantize_awq(args.model, args.output, args.bits)
+    elif args.method == "gptq":
+        result = quantize_gptq(args.model, args.output, args.bits)
+    elif args.method == "bnb":
+        result = quantize_bnb(args.model, args.output, args.bits)
+
+    if result and os.path.exists(result):
+        quantized_size = get_model_size(result)
+        print(f"\n量化后模型大小: {quantized_size:.2f} GB")
+        if os.path.exists(args.model):
+            compression = (1 - quantized_size / original_size) * 100
+            print(f"压缩率: {compression:.1f}%")
+
+    # 测试
+    if args.test and result:
+        test_quantized_model(result, args.bits)

inference/sglang_serve.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+"""
+Qwen3.5-0.8B-HOS SGLang 推理服务
+
+支持特性：
+- RadixAttention：前缀缓存加速，重复前缀请求速度提升 3-5x
+- JSON Schema 约束生成：确保输出符合指定格式
+- 高效连续批处理
+
+使用方法：
+  # 启动服务
+  python sglang_serve.py --serve
+
+  # 带 JSON 约束的推理测试
+  python sglang_serve.py --test
+
+  # 命令行交互
+  python sglang_serve.py --chat
+"""
+
+import argparse
+import json
+import time
+import torch
+
+
+def load_model(model_path="lxcxjxhx/Qwen3.5-0.8B-HOS"):
+    """加载模型到 SGLang 引擎"""
+    import sglang as sgl
+
+    # RadixAttention 自动启用
+    runtime = sgl.Runtime(
+        model_path=model_path,
+        # 0.8B 小模型配置
+        tp_size=1,
+        mem_fraction_static=0.9,
+        context_length=8192,
+        trust_remote_code=True,
+    )
+    return runtime
+
+
+def serve(model_path="lxcxjxhx/Qwen3.5-0.8B-HOS", host="0.0.0.0", port=30000):
+    """启动 SGLang OpenAI 兼容 API 服务
+
+    启动后可通过以下方式调用：
+    curl http://localhost:30000/v1/completions \\
+      -H "Content-Type: application/json" \\
+      -d '{"model": "Qwen3.5-0.8B-HOS", "prompt": "什么是SQL注入？", "max_tokens": 256}'
+    """
+    import sglang as sgl
+
+    print(f"启动 SGLang 服务: http://{host}:{port}")
+    print(f"模型: {model_path}")
+    print("特性: RadixAttention, Continuous Batching, JSON Schema 约束生成")
+
+    runtime = sgl.Runtime(
+        model_path=model_path,
+        host=host,
+        port=port,
+        tp_size=1,
+        mem_fraction_static=0.9,
+        context_length=8192,
+        trust_remote_code=True,
+    )
+
+    print(f"\n服务已启动，按 Ctrl+C 停止")
+    try:
+        runtime.loop()
+    except KeyboardInterrupt:
+        runtime.shutdown()
+        print("\n服务已停止")
+
+
+def test_json_constrained(model_path="lxcxjxhx/Qwen3.5-0.8B-HOS"):
+    """测试 JSON Schema 约束生成"""
+    import sglang as sgl
+
+    print(f"加载模型: {model_path}")
+    sgl.set_default_backend(sgl.RuntimeEndpoint(f"http://localhost:30000"))
+
+    # 定义安全事件分析的 JSON Schema
+    security_schema = {
+        "type": "object",
+        "properties": {
+            "threat_level": {"type": "string", "enum": ["low", "medium", "high", "critical"]},
+            "attack_type": {"type": "string"},
+            "affected_system": {"type": "string"},
+            "recommendation": {"type": "string"},
+            "confidence": {"type": "number", "minimum": 0, "maximum": 1},
+        },
+        "required": ["threat_level", "attack_type", "recommendation"],
+    }
+
+    @sgl.function
+    def analyze_security(s, log_entry):
+        s += f"分析以下安全日志条目，以 JSON 格式输出分析结果：\n{log_entry}\n"
+        s += sgl.gen("analysis", max_tokens=256, json_schema=security_schema)
+
+    test_logs = [
+        "2024-01-15 03:22:11 ALERT: Multiple failed SSH login attempts from 192.168.1.100 (50 attempts in 5 minutes)",
+        "2024-01-15 04:15:33 WARNING: Unusual outbound traffic detected from server-web-01 to external IP 203.0.113.50 on port 4444",
+        "2024-01-15 05:01:22 CRITICAL: SQL injection pattern detected in web request: ' OR 1=1; DROP TABLE users;--",
+    ]
+
+    print(f"\n=== JSON 约束生成测试 ===")
+    for i, log in enumerate(test_logs):
+        start = time.time()
+        state = analyze_security.run(log=log)
+        elapsed = time.time() - start
+
+        print(f"\n--- 日志 {i+1} ---")
+        print(f"输入: {log[:80]}...")
+        try:
+            result = json.loads(state["analysis"])
+            print(f"分析结果: {json.dumps(result, indent=2, ensure_ascii=False)}")
+        except json.JSONDecodeError:
+            print(f"原始输出: {state['analysis']}")
+        print(f"耗时: {elapsed:.2f}s")
+
+
+def test_inference(model_path="lxcxjxhx/Qwen3.5-0.8B-HOS"):
+    """基础推理测试"""
+    import sglang as sgl
+
+    print(f"加载模型: {model_path}")
+    runtime = load_model(model_path)
+
+    prompts = [
+        "请解释SQL注入攻击的原理和防御方法。",
+        "什么是XSS跨站脚本攻击？如何防范？",
+        "描述一次渗透测试的完整流程。",
+    ]
+
+    print(f"\n=== SGLang 推理测试 ===")
+    start = time.time()
+
+    # 使用 RadixAttention 的批处理推理
+    outputs = runtime.generate(
+        prompts,
+        sampling_params={
+            "temperature": 0.7,
+            "top_p": 0.9,
+            "max_new_tokens": 256,
+        },
+    )
+
+    elapsed = time.time() - start
+    total_tokens = sum(len(o["token_ids"]) for o in outputs)
+
+    print(f"总耗时: {elapsed:.2f}s")
+    print(f"总 token 数: {total_tokens}")
+    print(f"吞吐量: {total_tokens / elapsed:.1f} tokens/s")
+
+    for i, output in enumerate(outputs):
+        print(f"\n--- 请求 {i+1} ---")
+        print(f"生成: {output['text'][:200]}...")
+
+    runtime.shutdown()
+
+
+def chat_mode(model_path="lxcxjxhx/Qwen3.5-0.8B-HOS"):
+    """命令行交互模式"""
+    runtime = load_model(model_path)
+
+    print("\n=== Qwen3.5-0.8B-HOS SGLang 交互模式 ===")
+    print("输入 'quit' 或 'exit' 退出\n")
+
+    while True:
+        try:
+            user_input = input("用户: ").strip()
+            if user_input.lower() in ("quit", "exit", "q"):
+                break
+            if not user_input:
+                continue
+
+            prompt = f"<|im_start|>user\n{user_input}<|im_end|>\n<|im_start|>assistant\n"
+
+            start = time.time()
+            outputs = runtime.generate(
+                [prompt],
+                sampling_params={
+                    "temperature": 0.7,
+                    "top_p": 0.9,
+                    "max_new_tokens": 512,
+                },
+            )
+            elapsed = time.time() - start
+
+            response = outputs[0]["text"]
+            token_count = len(outputs[0]["token_ids"])
+
+            print(f"\n助手: {response}")
+            print(f"[{token_count} tokens, {elapsed:.2f}s, {token_count/elapsed:.1f} tokens/s]\n")
+
+        except KeyboardInterrupt:
+            break
+
+    runtime.shutdown()
+    print("\n再见！")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Qwen3.5-0.8B-HOS SGLang 推理服务")
+    parser.add_argument("--model", type=str, default="lxcxjxhx/Qwen3.5-0.8B-HOS",
+                        help="模型路径或 HF 仓库 ID")
+    parser.add_argument("--serve", action="store_true", help="启动 API 服务")
+    parser.add_argument("--test", action="store_true", help="运行推理测试")
+    parser.add_argument("--test-json", action="store_true", help="测试 JSON 约束生成")
+    parser.add_argument("--chat", action="store_true", help="命令行交互模式")
+    parser.add_argument("--host", type=str, default="0.0.0.0", help="服务监听地址")
+    parser.add_argument("--port", type=int, default=30000, help="服务端口")
+
+    args = parser.parse_args()
+
+    if args.serve:
+        serve(args.model, args.host, args.port)
+    elif args.test:
+        test_inference(args.model)
+    elif args.test_json:
+        test_json_constrained(args.model)
+    elif args.chat:
+        chat_mode(args.model)
+    else:
+        serve(args.model, args.host, args.port)

inference/vllm_serve.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+Qwen3.5-0.8B-HOS vLLM 推理服务
+
+支持特性：
+- PagedAttention：动态 KV cache 管理，提升吞吐量
+- Continuous Batching：动态批处理，减少 padding 开销
+- torch.compile 算子融合加速
+
+使用方法：
+  # 启动 OpenAI 兼容 API 服务
+  python vllm_serve.py --serve
+
+  # 直接推理测试
+  python vllm_serve.py --test
+
+  # 命令行交互
+  python vllm_serve.py --chat
+"""
+
+import argparse
+import time
+import torch
+
+
+def load_model(model_path="lxcxjxhx/Qwen3.5-0.8B-HOS", dtype="bfloat16"):
+    """加载模型到 vLLM 引擎"""
+    from vllm import LLM, SamplingParams
+
+    dtype_map = {
+        "bfloat16": torch.bfloat16,
+        "float16": torch.float16,
+        "float32": torch.float32,
+    }
+
+    llm = LLM(
+        model=model_path,
+        dtype=dtype_map.get(dtype, torch.bfloat16),
+        # PagedAttention 配置
+        gpu_memory_utilization=0.9,
+        max_model_len=8192,
+        # Continuous Batching（vLLM 默认启用）
+        max_num_seqs=256,
+        # 0.8B 小模型单卡无需 tensor parallelism
+        tensor_parallel_size=1,
+        # 启用 torch.compile 加速
+        enforce_eager=False,
+        trust_remote_code=True,
+    )
+    return llm
+
+
+def serve(model_path="lxcxjxhx/Qwen3.5-0.8B-HOS", host="0.0.0.0", port=8000):
+    """启动 OpenAI 兼容 API 服务
+
+    启动后可通过以下方式调用：
+    curl http://localhost:8000/v1/completions \\
+      -H "Content-Type: application/json" \\
+      -d '{"model": "Qwen3.5-0.8B-HOS", "prompt": "什么是SQL注入？", "max_tokens": 256}'
+    """
+    print(f"启动 vLLM 服务: http://{host}:{port}")
+    print(f"模型: {model_path}")
+    print("API 端点: /v1/completions, /v1/chat/completions")
+
+    # 使用 vLLM 内置的 OpenAI 兼容服务器
+    from vllm.entrypoints.openai.api_server import run_server
+    import uvicorn
+
+    uvicorn.run(
+        "vllm.entrypoints.openai.api_server:app",
+        host=host,
+        port=port,
+        log_level="info",
+    )
+
+
+def test_inference(model_path="lxcxjxhx/Qwen3.5-0.8B-HOS"):
+    """推理性能测试"""
+    from vllm import LLM, SamplingParams
+
+    print(f"加载模型: {model_path}")
+    llm = load_model(model_path)
+
+    # 测试用例：信息安全领域问题
+    prompts = [
+        "请解释SQL注入攻击的原理和防御方法。",
+        "什么是XSS跨站脚本攻击？如何防范？",
+        "描述一次渗透测试的完整流程。",
+        "如何使用Wireshark进行网络流量分析？",
+        "解释RSA加密算法的工作原理。",
+    ]
+
+    sampling_params = SamplingParams(
+        temperature=0.7,
+        top_p=0.9,
+        max_tokens=256,
+    )
+
+    print(f"\n测试 {len(prompts)} 个请求...")
+    start = time.time()
+    outputs = llm.generate(prompts, sampling_params)
+    elapsed = time.time() - start
+
+    total_tokens = sum(len(o.outputs[0].token_ids) for o in outputs)
+    print(f"\n=== 推理测试结果 ===")
+    print(f"总耗时: {elapsed:.2f}s")
+    print(f"总生成 token 数: {total_tokens}")
+    print(f"吞吐量: {total_tokens / elapsed:.1f} tokens/s")
+    print(f"平均每请求: {elapsed / len(prompts):.2f}s")
+
+    for i, output in enumerate(outputs):
+        print(f"\n--- 请求 {i+1} ---")
+        print(f"Prompt: {output.prompt[:50]}...")
+        print(f"生成: {output.outputs[0].text[:200]}...")
+        print(f"Token 数: {len(output.outputs[0].token_ids)}")
+
+
+def chat_mode(model_path="lxcxjxhx/Qwen3.5-0.8B-HOS"):
+    """命令行交互模式"""
+    from vllm import LLM, SamplingParams
+
+    print(f"加载模型: {model_path}")
+    llm = load_model(model_path)
+
+    sampling_params = SamplingParams(
+        temperature=0.7,
+        top_p=0.9,
+        max_tokens=512,
+    )
+
+    print("\n=== Qwen3.5-0.8B-HOS 交互模式 ===")
+    print("输入 'quit' 或 'exit' 退出\n")
+
+    while True:
+        try:
+            user_input = input("用户: ").strip()
+            if user_input.lower() in ("quit", "exit", "q"):
+                break
+            if not user_input:
+                continue
+
+            # 构造 chat template
+            prompt = f"<|im_start|>user\n{user_input}<|im_end|>\n<|im_start|>assistant\n"
+
+            start = time.time()
+            outputs = llm.generate([prompt], sampling_params)
+            elapsed = time.time() - start
+
+            response = outputs[0].outputs[0].text
+            token_count = len(outputs[0].outputs[0].token_ids)
+
+            print(f"\n助手: {response}")
+            print(f"[{token_count} tokens, {elapsed:.2f}s, {token_count/elapsed:.1f} tokens/s]\n")
+
+        except KeyboardInterrupt:
+            break
+
+    print("\n再见！")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Qwen3.5-0.8B-HOS vLLM 推理服务")
+    parser.add_argument("--model", type=str, default="lxcxjxhx/Qwen3.5-0.8B-HOS",
+                        help="模型路径或 HF 仓库 ID")
+    parser.add_argument("--dtype", type=str, default="bfloat16",
+                        choices=["bfloat16", "float16", "float32"],
+                        help="推理精度")
+    parser.add_argument("--serve", action="store_true", help="启动 API 服务")
+    parser.add_argument("--test", action="store_true", help="运行推理测试")
+    parser.add_argument("--chat", action="store_true", help="命令行交互模式")
+    parser.add_argument("--host", type=str, default="0.0.0.0", help="服务监听地址")
+    parser.add_argument("--port", type=int, default=8000, help="服务端口")
+
+    args = parser.parse_args()
+
+    if args.serve:
+        serve(args.model, args.host, args.port)
+    elif args.test:
+        test_inference(args.model)
+    elif args.chat:
+        chat_mode(args.model)
+    else:
+        # 默认启动服务
+        serve(args.model, args.host, args.port)

model.safetensors-00001-of-00001.safetensors

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c2b1e5a17d9c1e27685d92ed9b382911ebb99955ecd89052d1721241adfbab6c
-size 1746942600

requirements.txt

@@ -0,0 +1,31 @@
+# Qwen3.5-0.8B-HOS 训练依赖
+# 适用于 LLaMA-Factory QLoRA 训练流程
+
+# 核心依赖
+transformers>=4.40.0
+tokenizers>=0.19.0
+accelerate>=0.29.0
+peft>=0.10.0
+bitsandbytes>=0.43.0
+
+# 数据处理
+datasets>=2.18.0
+huggingface-hub>=0.22.0
+
+# 去重和清洗
+datasketch>=1.6.5
+simhash>=2.1.2
+
+# 训练优化
+einops>=0.7.0
+scipy>=1.13.0
+
+# 推理加速
+vllm>=0.4.0
+
+# 工具库
+tqdm>=4.66.0
+rich>=13.7.0
+
+# 日志和监控
+tensorboard>=2.16.0

run.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+# 主入口脚本 - 串联所有训练步骤
+# 适用于 Qwen3.5-0.8B-HOS 训练流程
+
+set -e
+
+echo "============================================"
+echo "  HOS Security Model Training"
+echo "  Qwen3.5-0.8B-HOS"
+echo "============================================"
+
+# 解析参数
+NO_PROXY=false
+for arg in "$@"; do
+    case $arg in
+        --no-proxy)
+            NO_PROXY=true
+            shift
+            ;;
+    esac
+done
+
+# Step 1: 代理配置（可选）
+if [ "$NO_PROXY" = false ]; then
+    echo "[1/5] 配置网络代理..."
+    source scripts/setup_proxy.sh
+else
+    echo "[1/5] 跳过代理配置"
+fi
+
+# Step 2: 安装依赖
+echo "[2/5] 安装环境依赖..."
+bash scripts/prepare_env.sh
+
+# Step 3: 下载并清洗数据
+echo "[3/5] 准备数据集..."
+bash scripts/prepare_data.sh
+
+# Step 4: 训练
+echo "[4/5] 启动训练..."
+bash scripts/train.sh
+
+# Step 5: 上传
+echo "[5/5] 上传模型..."
+bash scripts/upload.sh
+
+echo "============================================"
+echo "  训练完成!"
+echo "  模型: https://huggingface.co/lxcxjxhx/Qwen3.5-0.8B-HOS"
+echo "============================================"

scripts/clean_data.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+数据清洗脚本 - 用于清洗和预处理网络安全训练数据
+适用于 Qwen3.5-0.8B-HOS 训练流程
+
+功能：
+1. 去重（MinHash + SimHash）
+2. 去噪（移除低质量数据）
+3. 格式标准化（统一为 Alpaca 格式）
+4. 隐私脱敏（移除敏感信息）
+"""
+
+import json
+import os
+import re
+import hashlib
+from typing import Dict, List, Optional
+from datasketch import MinHash, MinHashLSH
+from simhash import Simhash
+
+
+# 配置
+DATA_DIR = "datasets"
+OUTPUT_DIR = "datasets/cleaned"
+
+
+def compute_minhash(text: str, num_perm: int = 128) -> MinHash:
+    """计算文本的 MinHash 签名"""
+    m = MinHash(num_perm=num_perm)
+    for word in text.split():
+        m.update(word.encode('utf-8'))
+    return m
+
+
+def compute_simhash(text: str, hashbits: int = 64) -> Simhash:
+    """计算文本的 SimHash 指纹"""
+    return Simhash(text, hashbits=hashbits)
+
+
+def deduplicate_minhash(data: List[Dict], threshold: float = 0.8) -> List[Dict]:
+    """使用 MinHash 进行去重"""
+    print(f"  MinHash 去重 (阈值: {threshold})...")
+    lsh = MinHashLSH(threshold=threshold, num_perm=128)
+    
+    unique_data = []
+    duplicates = 0
+    
+    for idx, item in enumerate(data):
+        text = f"{item.get('instruction', '')} {item.get('input', '')} {item.get('output', '')}"
+        m = compute_minhash(text)
+        
+        key = f"doc_{idx}"
+        if not lsh.query(m):
+            lsh.insert(key, m)
+            unique_data.append(item)
+        else:
+            duplicates += 1
+    
+    print(f"    原始: {len(data)}, 去重后: {len(unique_data)}, 移除: {duplicates}")
+    return unique_data
+
+
+def deduplicate_simhash(data: List[Dict], threshold: int = 3) -> List[Dict]:
+    """使用 SimHash 进行去重"""
+    print(f"  SimHash 去重 (汉明距离阈值: {threshold})...")
+    
+    unique_data = []
+    seen_hashes = []
+    duplicates = 0
+    
+    for item in data:
+        text = f"{item.get('instruction', '')} {item.get('input', '')} {item.get('output', '')}"
+        sh = compute_simhash(text)
+        
+        is_duplicate = False
+        for seen_sh in seen_hashes:
+            if sh.distance(seen_sh) <= threshold:
+                is_duplicate = True
+                duplicates += 1
+                break
+        
+        if not is_duplicate:
+            seen_hashes.append(sh)
+            unique_data.append(item)
+    
+    print(f"    原始: {len(data)}, 去重后: {len(unique_data)}, 移除: {duplicates}")
+    return unique_data
+
+
+def remove_noise(data: List[Dict]) -> List[Dict]:
+    """去噪 - 移除低质量数据"""
+    print("  去噪处理...")
+    
+    clean_data = []
+    removed = 0
+    
+    for item in data:
+        instruction = item.get('instruction', '')
+        input_text = item.get('input', '')
+        output = item.get('output', '')
+        
+        # 过滤条件
+        # 1. 移除空内容
+        if not instruction or not output:
+            removed += 1
+            continue
+        
+        # 2. 移除过短的内容
+        if len(output.strip()) < 10:
+            removed += 1
+            continue
+        
+        # 3. 移除明显无关的内容
+        noise_patterns = [
+            r'^\s*$',  # 纯空白
+            r'^(test|测试|demo|示例)\s*$',  # 测试内容
+            r'^(TODO|FIXME|HACK)',  # 代码注释
+        ]
+        
+        is_noise = False
+        for pattern in noise_patterns:
+            if re.search(pattern, output, re.IGNORECASE):
+                is_noise = True
+                break
+        
+        if is_noise:
+            removed += 1
+            continue
+        
+        clean_data.append(item)
+    
+    print(f"    原始: {len(data)}, 去噪后: {len(clean_data)}, 移除: {removed}")
+    return clean_data
+
+
+def standardize_format(data: List[Dict]) -> List[Dict]:
+    """格式标准化 - 统一为 Alpaca 格式"""
+    print("  格式标准化...")
+    
+    standardized = []
+    
+    for item in data:
+        # 确保必要的字段存在
+        standardized_item = {
+            'instruction': item.get('instruction', '').strip(),
+            'input': item.get('input', '').strip(),
+            'output': item.get('output', '').strip()
+        }
+        
+        # 清理多余空白
+        for key in standardized_item:
+            standardized_item[key] = re.sub(r'\s+', ' ', standardized_item[key]).strip()
+        
+        standardized.append(standardized_item)
+    
+    print(f"    标准化完成: {len(standardized)} 条记录")
+    return standardized
+
+
+def desensitize(data: List[Dict]) -> List[Dict]:
+    """隐私脱敏 - 移除敏感信息"""
+    print("  隐私脱敏...")
+    
+    desensitized = []
+    
+    # 敏感信息正则表达式
+    sensitive_patterns = {
+        'email': r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
+        'phone': r'\b1[3-9]\d{9}\b',  # 中国大陆手机号
+        'id_card': r'\b\d{17}[\dXx]\b',  # 身份证号
+        'ip': r'\b(?:\d{1,3}\.){3}\d{1,3}\b',  # IP 地址
+        'password': r'(password|密码|pwd)\s*[:=]\s*\S+',  # 密码
+        'api_key': r'(api[_-]?key|apikey)\s*[:=]\s*[\w-]+',  # API Key
+        'token': r'(token|access[_-]?token)\s*[:=]\s*[\w.-]+',  # Token
+    }
+    
+    for item in data:
+        new_item = item.copy()
+        
+        for key in ['instruction', 'input', 'output']:
+            text = new_item.get(key, '')
+            
+            # 替换敏感信息
+            for pattern_name, pattern in sensitive_patterns.items():
+                if pattern_name in ['email', 'phone', 'id_card']:
+                    text = re.sub(pattern, f'<{pattern_name.upper()}>', text)
+                elif pattern_name in ['password', 'api_key', 'token']:
+                    text = re.sub(pattern, f'<{pattern_name.upper()}>', text, flags=re.IGNORECASE)
+            
+            new_item[key] = text
+        
+        desensitized.append(new_item)
+    
+    print(f"    脱敏完成: {len(desensitized)} 条记录")
+    return desensitized
+
+
+def process_dataset(input_file: str, output_file: str):
+    """处理单个数据集文件"""
+    print(f"\n处理: {input_file}")
+    
+    # 读取数据
+    data = []
+    with open(input_file, 'r', encoding='utf-8') as f:
+        for line in f:
+            if line.strip():
+                data.append(json.loads(line))
+    
+    print(f"  原始数据: {len(data)} 条")
+    
+    # 1. 去重 (MinHash)
+    data = deduplicate_minhash(data, threshold=0.8)
+    
+    # 2. 去重 (SimHash)
+    data = deduplicate_simhash(data, threshold=3)
+    
+    # 3. 去噪
+    data = remove_noise(data)
+    
+    # 4. 格式标准化
+    data = standardize_format(data)
+    
+    # 5. 隐私脱敏
+    data = desensitize(data)
+    
+    # 保存结果
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for item in data:
+            f.write(json.dumps(item, ensure_ascii=False) + '\n')
+    
+    print(f"  处理后数据: {len(data)} 条")
+    print(f"  保存至: {output_file}")
+
+
+def main():
+    """主函数"""
+    print("============================================")
+    print("  数据清洗脚本")
+    print("  Qwen3.5-0.8B-HOS")
+    print("============================================")
+    
+    # 创建输出目录
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    
+    # 处理所有数据集
+    datasets = [
+        'cybersecurity_hq.jsonl',
+        'cybersecurity_sharegpt.jsonl',
+        'cnvd_vulnerability.jsonl',
+        'merged_cybersec.jsonl'
+    ]
+    
+    for dataset in datasets:
+        input_file = os.path.join(DATA_DIR, dataset)
+        output_file = os.path.join(OUTPUT_DIR, dataset)
+        
+        if os.path.exists(input_file):
+            process_dataset(input_file, output_file)
+        else:
+            print(f"\n跳过: {input_file} (文件不存在)")
+    
+    print("\n============================================")
+    print("  数据清洗完成!")
+    print(f"  输出目录: {OUTPUT_DIR}")
+    print("============================================")
+
+
+if __name__ == "__main__":
+    main()

scripts/prepare_data.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+# 数据下载与清洗脚本
+# 适用于 Qwen3.5-0.8B-HOS 训练流程
+
+set -e
+
+echo "============================================"
+echo "  准备训练数据集"
+echo "============================================"
+
+# 数据集目录
+DATA_DIR="datasets"
+mkdir -p "$DATA_DIR"
+
+# 从 HuggingFace 下载数据集
+echo "[1/4] 下载数据集..."
+python -c "
+from datasets import load_dataset
+from huggingface_hub import hf_hub_download
+import os
+
+# 下载 infosec-dataset-training 数据集
+print('下载 cybersecurity_hq...')
+ds = load_dataset('lxcxjxhx/infosec-dataset-training', 'cybersecurity_hq', trust_remote_code=True)
+ds['train'].to_json(os.path.join('$DATA_DIR', 'cybersecurity_hq.jsonl'), orient='records', lines=True, force_ascii=False)
+
+print('下载 cybersecurity_sharegpt...')
+ds = load_dataset('lxcxjxhx/infosec-dataset-training', 'cybersecurity_sharegpt', trust_remote_code=True)
+ds['train'].to_json(os.path.join('$DATA_DIR', 'cybersecurity_sharegpt.jsonl'), orient='records', lines=True, force_ascii=False)
+
+print('下载 cnvd_vulnerability...')
+ds = load_dataset('lxcxjxhx/infosec-dataset-training', 'cnvd_vulnerability', trust_remote_code=True)
+ds['train'].to_json(os.path.join('$DATA_DIR', 'cnvd_vulnerability.jsonl'), orient='records', lines=True, force_ascii=False)
+
+print('下载 merged_cybersec...')
+ds = load_dataset('lxcxjxhx/infosec-dataset-training', 'merged_cybersec', trust_remote_code=True)
+ds['train'].to_json(os.path.join('$DATA_DIR', 'merged_cybersec.jsonl'), orient='records', lines=True, force_ascii=False)
+
+print('数据集下载完成!')
+"
+
+# 数据清洗
+echo "[2/4] 数据清洗..."
+python scripts/clean_data.py
+
+# 验证数据集
+echo "[3/4] 验证数据集..."
+python -c "
+import json
+import os
+
+data_dir = '$DATA_DIR'
+files = ['cybersecurity_hq.jsonl', 'cybersecurity_sharegpt.jsonl', 'cnvd_vulnerability.jsonl', 'merged_cybersec.jsonl']
+
+for f in files:
+    path = os.path.join(data_dir, f)
+    if os.path.exists(path):
+        with open(path, 'r', encoding='utf-8') as file:
+            count = sum(1 for _ in file)
+        print(f'{f}: {count} 条记录')
+    else:
+        print(f'{f}: 文件不存在!')
+"
+
+# 复制 dataset_info.json
+echo "[4/4] 配置数据集信息..."
+cp datasets/dataset_info.json "$DATA_DIR/dataset_info.json" 2>/dev/null || echo "dataset_info.json 已存在"
+
+echo "============================================"
+echo "  数据集准备完成!"
+echo "============================================"

scripts/prepare_env.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+# 环境安装脚本 - 安装训练所需的所有依赖
+# 适用于 Qwen3.5-0.8B-HOS 训练流程
+
+set -e
+
+echo "============================================"
+echo "  安装训练环境依赖"
+echo "============================================"
+
+# 检查 Python 版本
+echo "[1/6] 检查 Python 版本..."
+python --version
+
+# 升级 pip
+echo "[2/6] 升级 pip..."
+python -m pip install --upgrade pip
+
+# 安装 PyTorch (CUDA 12.1)
+echo "[3/6] 安装 PyTorch..."
+pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
+
+# 安装 LLaMA-Factory
+echo "[4/6] 安装 LLaMA-Factory..."
+pip install git+https://github.com/hiyouga/LLaMA-Factory.git
+
+# 安装 Unsloth (加速训练)
+echo "[5/6] 安装 Unsloth..."
+pip install unsloth
+
+# 安装 vLLM (推理加速)
+echo "[6/6] 安装 vLLM..."
+pip install vllm
+
+# 安装其他依赖
+echo "[7/7] 安装其他依赖..."
+pip install -r requirements.txt
+
+# 验证安装
+echo "============================================"
+echo "  验证安装..."
+echo "============================================"
+python -c "import torch; print(f'PyTorch: {torch.__version__}')"
+python -c "import torch; print(f'CUDA Available: {torch.cuda.is_available()}')"
+python -c "import torch; print(f'CUDA Version: {torch.version.cuda}')"
+python -c "import transformers; print(f'Transformers: {transformers.__version__}')"
+
+echo "============================================"
+echo "  环境安装完成!"
+echo "============================================"

scripts/setup_proxy.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# 代理配置脚本 - 配置网络代理以访问外部资源
+# 适用于 Qwen3.5-0.8B-HOS 训练流程
+
+echo "============================================"
+echo "  配置网络代理 (端口 7897)"
+echo "============================================"
+
+# 设置代理环境变量
+export http_proxy=http://127.0.0.1:7897
+export https_proxy=http://127.0.0.1:7897
+export HTTP_PROXY=http://127.0.0.1:7897
+export HTTPS_PROXY=http://127.0.0.1:7897
+
+# Git 代理配置
+git config --global http.proxy http://127.0.0.1:7897
+git config --global https.proxy http://127.0.0.1:7897
+
+# HuggingFace 代理配置
+export HF_HUB_ENABLE_HF_TRANSFER=1
+
+echo "代理配置完成:"
+echo "  HTTP_PROXY:  $http_proxy"
+echo "  HTTPS_PROXY: $https_proxy"
+echo "============================================"

scripts/train.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+# 训练启动脚本 - 使用 LLaMA-Factory 进行 QLoRA 训练
+# 适用于 Qwen3.5-0.8B-HOS 训练流程
+
+set -e
+
+echo "============================================"
+echo "  启动 QLoRA 训练"
+echo "  模型: Qwen3.5-0.8B-HOS"
+echo "============================================"
+
+# 检查配置文件
+CONFIG_FILE="configs/train.yaml"
+if [ ! -f "$CONFIG_FILE" ]; then
+    echo "错误: 配置文件不存在: $CONFIG_FILE"
+    exit 1
+fi
+
+# 检查数据集
+DATASET_DIR="datasets"
+if [ ! -d "$DATASET_DIR" ]; then
+    echo "错误: 数据集目录不存在: $DATASET_DIR"
+    exit 1
+fi
+
+# 创建输出目录
+OUTPUT_DIR="outputs/qwen35-0.8b-cybersec-qlora"
+mkdir -p "$OUTPUT_DIR"
+
+# 显示训练配置
+echo "训练配置:"
+echo "  配置文件: $CONFIG_FILE"
+echo "  数据集目录: $DATASET_DIR"
+echo "  输出目录: $OUTPUT_DIR"
+echo ""
+
+# 显示系统信息
+echo "系统信息:"
+python -c "import torch; print(f'  PyTorch: {torch.__version__}')"
+python -c "import torch; print(f'  CUDA Available: {torch.cuda.is_available()}')"
+if python -c "import torch; exit(0 if torch.cuda.is_available() else 1)" 2>/dev/null; then
+    python -c "import torch; print(f'  GPU: {torch.cuda.get_device_name(0)}')"
+    python -c "import torch; print(f'  GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB')"
+fi
+echo ""
+
+# 开始训练
+echo "开始训练..."
+echo "============================================"
+
+llamafactory-cli train "$CONFIG_FILE"
+
+echo "============================================"
+echo "  训练完成!"
+echo "  模型输出: $OUTPUT_DIR"
+echo "============================================"

scripts/upload.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# 上传脚本 - 合并 adapter 并上传到 HuggingFace Hub
+# 适用于 Qwen3.5-0.8B-HOS 训练流程
+
+set -e
+
+echo "============================================"
+echo "  上传模型到 HuggingFace Hub"
+echo "  目标: lxcxjxhx/Qwen3.5-0.8B-HOS"
+echo "============================================"
+
+# 配置
+OUTPUT_DIR="outputs/qwen35-0.8b-cybersec-qlora"
+MERGED_DIR="outputs/qwen35-0.8b-merged"
+HUB_MODEL_ID="lxcxjxhx/Qwen3.5-0.8B-HOS"
+
+# 检查训练输出
+if [ ! -d "$OUTPUT_DIR" ]; then
+    echo "错误: 训练输出目录不存在: $OUTPUT_DIR"
+    exit 1
+fi
+
+# Step 1: 合并 adapter
+echo "[1/3] 合并 LoRA adapter..."
+python -c "
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+import torch
+
+print('加载基础模型...')
+base_model = AutoModelForCausalLM.from_pretrained(
+    'lxcxjxhx/Qwen3.5-0.8B-HOS',
+    torch_dtype=torch.bfloat16,
+    trust_remote_code=True
+)
+
+print('加载 LoRA adapter...')
+model = PeftModel.from_pretrained(base_model, '$OUTPUT_DIR')
+
+print('合并模型...')
+model = model.merge_and_unload()
+
+print('保存合并后的模型...')
+model.save_pretrained('$MERGED_DIR')
+
+print('保存 tokenizer...')
+tokenizer = AutoTokenizer.from_pretrained('lxcxjxhx/Qwen3.5-0.8B-HOS', trust_remote_code=True)
+tokenizer.save_pretrained('$MERGED_DIR')
+
+print('合并完成!')
+"
+
+# Step 2: 推送到 HuggingFace Hub
+echo "[2/3] 推送到 HuggingFace Hub..."
+python -c "
+from huggingface_hub import HfApi
+
+api = HfApi()
+
+print('上传模型到: $HUB_MODEL_ID')
+api.upload_folder(
+    folder_path='$MERGED_DIR',
+    repo_id='$HUB_MODEL_ID',
+    repo_type='model',
+    commit_message='Upload Qwen3.5-0.8B-HOS merged model'
+)
+
+print('上传完成!')
+"
+
+# Step 3: 验证上传
+echo "[3/3] 验证上传..."
+python -c "
+from huggingface_hub import model_info
+
+info = model_info('$HUB_MODEL_ID')
+print(f'模型: {info.modelId}')
+print(f'最后更新: {info.lastModified}')
+print(f'标签: {info.tags}')
+print('验证完成!')
+"
+
+echo "============================================"
+echo "  上传完成!"
+echo "  模型地址: https://huggingface.co/$HUB_MODEL_ID"
+echo "============================================"