[cyber] new llm_train project

Author: tsymiar

LinxSrvc/cyber/.env

@@ -0,0 +1,4 @@
+*__pycache__
+.llama-tools
+outputs
+logs

LinxSrvc/cyber/.gitignore

@@ -0,0 +1,3 @@
+[submodule ".llama-tools/llama.cpp-to-hf"]
+	path = .llama-tools/llama.cpp-to-hf
+	url = https://github.com/ggerganov/llama.cpp-to-hf.git

LinxSrvc/cyber/.gitmodules

@@ -0,0 +1,105 @@
+# Ollama 模型转换工具
+
+将本地 Ollama 模型转换为 Hugging Face 格式，支持完整权重转换和简化配置转换。
+
+## 安装依赖
+
+```bash
+pip install -r requirements.txt
+pip install llama-cpp-python transformers safetensors
+```
+
+## 快速开始
+
+### 方式一：通过 Ollama 模型名转换
+
+```bash
+python scripts/ollama_to_hf.py \
+  --ollama-model qwen3.5:4b \
+  --output models/hf/qwen \
+  --hf-model Qwen/Qwen-7B
+```
+
+### 方式二：直接转换模型文件
+
+```bash
+python scripts/ollama_to_hf.py \
+  --model-file ./models/qwen.gguf \
+  --output models/hf/qwen \
+  --hf-model Qwen/Qwen-7B
+```
+
+支持以下文件格式：
+- `.gguf` - GGUF 格式模型
+- `.safetensors` - SafeTensors 格式模型
+- `.bin` - PyTorch Bin 格式模型
+- `.pt` - PyTorch PT 格式模型
+- **sha256 命名的文件** - 无扩展名的 blob 文件（自动检测格式）
+
+**注意**：对于 sha256 命名的文件（如 Ollama 的 blob 文件），脚本会自动检测文件格式。
+
+### 转换 sha256 命名的文件
+
+```bash
+python scripts/ollama_to_hf.py \
+  --model-file ~/.ollama/models/blobs/sha256-aeaeda25e63... \
+  --output models/hf/qwen \
+  --hf-model Qwen/Qwen-7B
+```
+
+### 简化转换（仅 tokenizer 和配置）
+
+```bash
+python scripts/ollama_to_hf.py \
+  --ollama-model gemma3 \
+  --output models/hf/gemma3 \
+  --hf-model google/gemma-7b \
+  --simple-conversion
+```
+
+## 参数说明
+
+| 参数 | 说明 |
+|------|------|
+| `--ollama-model` | Ollama 模型名称（支持带 tag，如 `qwen3.5:4b`） |
+| `--model-file` | 直接指定模型文件路径（与 `--ollama-model` 互斥） |
+| `--output` | 输出目录路径（必需） |
+| `--hf-model` | 对应的 Hugging Face 模型名称（用于加载 tokenizer） |
+| `--tokenizer` | 指定 tokenizer 名称（覆盖 `--hf-model`） |
+| `--simple-conversion` | 仅保存 tokenizer 和配置，不转换权重 |
+| `--full-conversion` | 使用完整转换（GGUF 模型默认启用） |
+| `--force-install` | 强制重新安装转换工具 |
+| `-v` | 显示详细日志 |
+
+## 转换流程
+
+### 通过 Ollama 模型名转换
+
+1. 自动从 `~/.ollama/models/` 查找模型文件（通过 manifest 定位 blob）
+2. 自动检测 blob 存储格式：
+   - 新格式：`blobs/sha256/{digest[:2]}/{digest}`
+   - 旧格式：`blobs/sha256-{digest}`
+3. 支持 sha256 命名的无扩展名文件（自动检测格式）
+4. 首次运行自动安装 `llama.cpp` 转换工具到 `~/.llama-cpp-tools/`
+5. 从 Hugging Face 加载 tokenizer
+6. 执行模型转换并保存到输出目录
+
+### 直接转换模型文件
+
+1. 自动检测模型文件格式（通过扩展名或文件头）
+   - 有扩展名：根据扩展名识别（.gguf, .safetensors, .bin, .pt）
+   - 无扩展名（sha256 命名）：读取文件头自动识别格式
+2. 从 Hugging Face 加载 tokenizer
+3. 执行模型转换并保存到输出目录
+
+## 注意事项
+
+- 转换大模型需要较长时间，请耐心等待
+- 确保有足够的磁盘空间存储转换后的模型
+- 遵守模型的许可证要求
+
+## 相关链接
+
+- [llama.cpp](https://github.com/ggerganov/llama.cpp)
+- [Ollama](https://ollama.ai)
+- [Hugging Face Transformers](https://github.com/huggingface/transformers)

LinxSrvc/cyber/OLLAMA_TO_GUFF.md

@@ -0,0 +1,278 @@
+# data/dataset.py
+import json
+import os
+import torch
+from torch.utils.data import Dataset
+
+class ConversationDataset(Dataset):
+    """对话数据集
+
+    支持以下格式:
+    - 'raw': 原始文本格式，每行一个对话
+    - 'sharegpt': ShareGPT 格式，每行一个 JSON 对象
+    - 'alpaca': Alpaca 格式，包含 instruction, input, output 字段
+    """
+    def __init__(self, file_path, tokenizer, max_length=1024, data_format='raw', sharegpt_config=None):
+        """
+        Args:
+            file_path: 数据文件路径
+            tokenizer: HuggingFace tokenizer
+            max_length: 最大序列长度
+            data_format: 数据格式 ('raw', 'sharegpt', 'alpaca')
+            sharegpt_config: ShareGPT 格式配置
+
+        Raises:
+            FileNotFoundError: 文件不存在
+            ValueError: 参数无效或数据格式错误
+        """
+        # 参数验证
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"数据文件不存在: {file_path}")
+
+        if data_format not in ['raw', 'sharegpt', 'alpaca']:
+            raise ValueError(f"不支持的 data_format: {data_format}，必须是 'raw', 'sharegpt' 或 'alpaca'")
+
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        self.data_format = data_format
+        self.sharegpt_config = sharegpt_config or {}
+
+        # 加载数据
+        self.examples = self._load_data(file_path)
+
+        # 设置 pad token
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+
+    def _load_data(self, file_path):
+        """加载数据文件"""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                if self.data_format == 'sharegpt':
+                    # 每行是一个JSON对象
+                    examples = []
+                    for line_num, line in enumerate(f, 1):
+                        if line.strip():
+                            try:
+                                examples.append(json.loads(line))
+                            except json.JSONDecodeError as e:
+                                raise ValueError(f"第 {line_num} 行 JSON 解析失败: {e}")
+                    return examples
+                elif self.data_format == 'alpaca':
+                    # 每行是一个JSON对象
+                    examples = []
+                    for line_num, line in enumerate(f, 1):
+                        if line.strip():
+                            try:
+                                examples.append(json.loads(line))
+                            except json.JSONDecodeError as e:
+                                raise ValueError(f"第 {line_num} 行 JSON 解析失败: {e}")
+                    return examples
+                else:
+                    # raw 格式：每行是一个文本
+                    return [line.strip() for line in f if line.strip()]
+        except UnicodeDecodeError as e:
+            raise ValueError(f"文件编码错误: {e}")
+        except IOError as e:
+            raise IOError(f"读取文件失败: {e}")
+
+    def __len__(self):
+        return len(self.examples)
+
+    def __getitem__(self, idx):
+        """获取数据样本"""
+        try:
+            if self.data_format == 'sharegpt':
+                return self._process_sharegpt(idx)
+            elif self.data_format == 'alpaca':
+                return self._process_alpaca(idx)
+            else:
+                return self._process_raw(idx)
+        except Exception as e:
+            raise ValueError(f"处理第 {idx} 个样本时出错: {e}")
+
+    def _process_raw(self, idx):
+        """处理 raw 格式数据"""
+        text = self.examples[idx]
+
+        enc = self.tokenizer(
+            text,
+            truncation=True,
+            padding='max_length',
+            max_length=self.max_length,
+            return_tensors='pt'
+        )
+
+        input_ids = enc['input_ids'].squeeze()
+        attention_mask = enc['attention_mask'].squeeze()
+
+        # 对于 raw 格式，简单地将整个序列作为 labels
+        # 注意：这种方式会训练模型预测整个序列，包括 user 部分
+        # 如果有明确的 user/assistant 分隔，建议使用 sharegpt 格式
+        labels = input_ids.clone()
+
+        return {
+            'input_ids': input_ids,
+            'attention_mask': attention_mask,
+            'labels': labels
+        }
+
+    def _process_sharegpt(self, idx):
+        """处理 ShareGPT 格式数据
+
+        只计算 assistant 回复部分的损失，将 user 部分的 labels 设为 -100
+        """
+        conv = self.examples[idx]['conversations']
+
+        # 获取角色配置
+        human_role = self.sharegpt_config.get('human_role', 'human')
+        assistant_role = self.sharegpt_config.get('assistant_role', 'gpt')
+
+        # 构建文本
+        text_parts = []
+        label_parts = []
+
+        for turn in conv:
+            if turn['from'] == human_role:
+                # user 输入：不计算损失
+                user_text = f"User: {turn['value']}\n"
+                text_parts.append(user_text)
+                label_parts.append(None)  # 标记为不计算损失
+            elif turn['from'] == assistant_role:
+                # assistant 回复：计算损失
+                assistant_text = f"Assistant: {turn['value']}\n"
+                text_parts.append(assistant_text)
+                label_parts.append(True)  # 标记为计算损失
+
+        # 添加最后的提示符
+        text_parts.append("Assistant:")
+        label_parts.append(False)  # 提示符不计算损失
+
+        # 合并文本
+        full_text = "".join(text_parts)
+
+        # tokenize
+        enc = self.tokenizer(
+            full_text,
+            truncation=True,
+            padding='max_length',
+            max_length=self.max_length,
+            return_tensors='pt'
+        )
+
+        input_ids = enc['input_ids'].squeeze()
+        attention_mask = enc['attention_mask'].squeeze()
+
+        # 构建正确的 labels：只计算 assistant 回复部分
+        labels = input_ids.clone()
+
+        # 计算各部分的 token 范围
+        if len(text_parts) > 1:
+            cumulative_text = ""
+            token_positions = []
+
+            # 逐部分累积文本并记录对应的 token 范围
+            for part in text_parts:
+                part_start = len(self.tokenizer(
+                    cumulative_text,
+                    return_tensors='pt',
+                    add_special_tokens=False
+                )['input_ids'][0])
+
+                cumulative_text += part
+
+                part_end = len(self.tokenizer(
+                    cumulative_text,
+                    return_tensors='pt',
+                    add_special_tokens=False
+                )['input_ids'][0])
+
+                token_positions.append((part_start, part_end))
+
+            # 将应该忽略的部分设为 -100
+            for i, (pos, should_label) in enumerate(zip(token_positions, label_parts)):
+                if not should_label:
+                    start_pos, end_pos = pos
+                    if start_pos < len(labels):
+                        end_pos = min(end_pos, len(labels))
+                        labels[start_pos:end_pos] = -100
+
+        return {
+            'input_ids': input_ids,
+            'attention_mask': attention_mask,
+            'labels': labels
+        }
+
+    def _process_alpaca(self, idx):
+        """处理 Alpaca 格式数据
+
+        Alpaca 格式包含:
+        - instruction: 指令
+        - input: 输入（可选）
+        - output: 输出
+        """
+        example = self.examples[idx]
+
+        # 验证必需字段
+        if 'instruction' not in example or 'output' not in example:
+            raise ValueError(f"Alpaca 格式缺少必需字段 'instruction' 或 'output'")
+
+        instruction = example['instruction']
+        input_text = example.get('input', '')
+        output = example['output']
+
+        # 构建提示词
+        if input_text:
+            prompt = f"""Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
+
+### Instruction:
+{instruction}
+
+### Input:
+{input_text}
+
+### Response:
+"""
+        else:
+            prompt = f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
+
+### Instruction:
+{instruction}
+
+### Response:
+"""
+
+        # 完整文本 = prompt + output
+        full_text = prompt + output
+
+        # tokenize 完整文本
+        enc = self.tokenizer(
+            full_text,
+            truncation=True,
+            padding='max_length',
+            max_length=self.max_length,
+            return_tensors='pt'
+        )
+
+        input_ids = enc['input_ids'].squeeze()
+        attention_mask = enc['attention_mask'].squeeze()
+
+        # 构建 labels：只计算 output 部分
+        labels = input_ids.clone()
+
+        # 找到 prompt 的结束位置
+        prompt_enc = self.tokenizer(
+            prompt,
+            return_tensors='pt',
+            add_special_tokens=False
+        )
+        prompt_len = prompt_enc['input_ids'].shape[1]
+
+        # 将 prompt 部分设为 -100（不计算损失）
+        labels[:prompt_len] = -100
+
+        return {
+            'input_ids': input_ids,
+            'attention_mask': attention_mask,
+            'labels': labels
+        }

LinxSrvc/cyber/data/dataset.py

@@ -0,0 +1,2 @@
+我: 你好
+对方: 啊？