fix: M2/S2/S4/M4 defect repairs

M2: Fixed mini_data.json duplication (74% -> 0%), 57 unique samples
with balanced think_rank distribution (0:37%, 1:23%, 2:23%, 3:18%)
S2: Added QATTrainer class to DyQuant for quantization-aware training
integration (inserts fake-quant nodes, trains, exports quantized model)
S4: Ollama deploy now has fallback export for custom architectures
(SBLA/ThinkingDial) when llama.cpp convert-hf-to-gguf fails
M4: Added validate_think_rank.py script for distribution verification

New files:
- scripts/dedup_mini_data.py
- scripts/validate_think_rank.py

data/mini_data.json

@@ -1,542 +1,287 @@
 [
-  {
-    "prompt": "什么是大数据",
-    "response": "大数据是指规模巨大、类型多样的数据集合。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "How to learn coding",
-    "response": "Practice coding regularly and build projects.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "What is AI",
-    "response": "AI stands for Artificial Intelligence.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "Python features",
-    "response": "Python is simple, powerful, and versatile.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "Python features",
-    "response": "Python is simple, powerful, and versatile.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "Python features",
-    "response": "Python is simple, powerful, and versatile.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "什么是大数据",
-    "response": "大数据是指规模巨大、类型多样的数据集合。",
-    "think_rank": 0
-  },
   {
     "prompt": "Hello",
-    "response": "Hello! I am Fusion Mini model.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "How to learn coding",
-    "response": "Practice coding regularly and build projects.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "云计算的优势",
-    "response": "云计算提供弹性扩展、成本节约、易于维护等优势。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "什么是人工智能",
-    "response": "人工智能是计算机科学的一个分支，致力于创建智能机器。",
-    "think_rank": 1
-  },
-  {
-    "prompt": "How to learn coding",
-    "response": "Practice coding regularly and build projects.",
+    "response": "Hello! How can I help you today?",
     "think_rank": 0
   },
   {
-    "prompt": "Python 有什么特点",
-    "response": "Python 是一种简单易学、功能强大的编程语言。",
+    "prompt": "What is Python",
+    "response": "Python is a high-level programming language known for its readability and versatility.",
     "think_rank": 0
   },
   {
-    "prompt": "How blockchain works",
-    "response": "Blockchain is a distributed ledger technology.",
+    "prompt": "Define API",
+    "response": "API stands for Application Programming Interface, a set of rules for software communication.",
     "think_rank": 0
   },
   {
-    "prompt": "What is AI",
-    "response": "AI stands for Artificial Intelligence.",
+    "prompt": "What is HTML",
+    "response": "HTML is the standard markup language for creating web pages.",
     "think_rank": 0
   },
   {
-    "prompt": "How blockchain works",
-    "response": "Blockchain is a distributed ledger technology.",
+    "prompt": "Name a search engine",
+    "response": "Google is the most widely used search engine.",
     "think_rank": 0
   },
   {
-    "prompt": "What is big data",
-    "response": "Big data refers to extremely large datasets.",
+    "prompt": "What does CPU stand for",
+    "response": "CPU stands for Central Processing Unit, the brain of a computer.",
     "think_rank": 0
   },
   {
-    "prompt": "How blockchain works",
-    "response": "Blockchain is a distributed ledger technology.",
+    "prompt": "What is RAM",
+    "response": "RAM is Random Access Memory, used for temporary data storage during program execution.",
     "think_rank": 0
   },
   {
-    "prompt": "如何学习编程",
-    "response": "学习编程需要理论与实践相结合，多写代码多思考。",
-    "think_rank": 2
-  },
-  {
-    "prompt": "What is NLP",
-    "response": "NLP helps computers understand human language.",
+    "prompt": "What is WiFi",
+    "response": "WiFi is a wireless networking technology for internet connectivity.",
     "think_rank": 0
   },
   {
-    "prompt": "什么是自然语言处理",
-    "response": "自然语言处理是AI的一个分支，帮助计算机理解人类语言。",
+    "prompt": "What is a database",
+    "response": "A database is an organized collection of structured data stored electronically.",
     "think_rank": 0
   },
   {
-    "prompt": "什么是自然语言处理",
-    "response": "自然语言处理是AI的一个分支，帮助计算机理解人类语言。",
+    "prompt": "What is an operating system",
+    "response": "An operating system manages hardware and software resources on a computer.",
     "think_rank": 0
   },
   {
-    "prompt": "What is NLP",
-    "response": "NLP helps computers understand human language.",
+    "prompt": "What is cloud storage",
+    "response": "Cloud storage saves data on remote servers accessed via the internet.",
     "think_rank": 0
   },
   {
-    "prompt": "什么是自然语言处理",
-    "response": "自然语言处理是AI的一个分支，帮助计算机理解人类语言。",
+    "prompt": "What is encryption",
+    "response": "Encryption converts data into a coded format to prevent unauthorized access.",
     "think_rank": 0
   },
   {
-    "prompt": "Benefits of cloud computing",
-    "response": "Cloud computing offers scalability and cost savings.",
+    "prompt": "What is a URL",
+    "response": "A URL is a web address that specifies the location of a resource on the internet.",
     "think_rank": 0
   },
   {
-    "prompt": "What is NLP",
-    "response": "NLP helps computers understand human language.",
+    "prompt": "What is a browser",
+    "response": "A browser is software for accessing and viewing websites on the internet.",
     "think_rank": 0
   },
   {
-    "prompt": "深度学习是什么",
-    "response": "深度学习是机器学习的一个分支，使用多层神经网络模拟人脑。",
+    "prompt": "What is open source",
+    "response": "Open source software has source code that anyone can inspect, modify, and distribute.",
     "think_rank": 0
   },
   {
-    "prompt": "Python 有什么特点",
-    "response": "Python 是一种简单易学、功能强大的编程语言。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "How blockchain works",
-    "response": "Blockchain is a distributed ledger technology.",
-    "think_rank": 0
+    "prompt": "Write a function to reverse a string",
+    "response": "def reverse_string(s): return s[::-1]",
+    "think_rank": 1
   },
   {
-    "prompt": "如何学习编程",
-    "response": "学习编程需要理论与实践相结合，多写代码多思考。",
-    "think_rank": 2
+    "prompt": "Implement a function to check if a number is prime",
+    "response": "def is_prime(n): return n > 1 and all(n % i != 0 for i in range(2, int(n**0.5) + 1))",
+    "think_rank": 1
   },
   {
-    "prompt": "区块链的原理",
-    "response": "区块链是一种分布式账本技术，确保数据不可篡改。",
-    "think_rank": 0
+    "prompt": "Write a function to calculate factorial",
+    "response": "def factorial(n): return 1 if n <= 1 else n * factorial(n - 1)",
+    "think_rank": 1
   },
   {
-    "prompt": "区块链的原理",
-    "response": "区块链是一种分布式账本技术，确保数据不可篡改。",
-    "think_rank": 0
+    "prompt": "Implement binary search in Python",
+    "response": "def binary_search(arr, target):\n    lo, hi = 0, len(arr) - 1\n    while lo <= hi:\n        mid = (lo + hi) // 2\n        if arr[mid] == target: return mid\n        elif arr[mid] < target: lo = mid + 1\n        else: hi = mid - 1\n    return -1",
+    "think_rank": 1
   },
   {
-    "prompt": "你好",
-    "response": "你好！我是 Fusion Mini 模型。",
-    "think_rank": 0
+    "prompt": "Write a function to sort a list",
+    "response": "def sort_list(lst): return sorted(lst)",
+    "think_rank": 1
   },
   {
-    "prompt": "What is AI",
-    "response": "AI stands for Artificial Intelligence.",
-    "think_rank": 0
+    "prompt": "Implement a stack data structure",
+    "response": "class Stack:\n    def __init__(self): self.items = []\n    def push(self, item): self.items.append(item)\n    def pop(self): return self.items.pop() if self.items else None",
+    "think_rank": 1
   },
   {
-    "prompt": "Hello",
-    "response": "Hello! I am Fusion Mini model.",
-    "think_rank": 0
+    "prompt": "Write code to read a CSV file",
+    "response": "import csv\nwith open('file.csv') as f:\n    reader = csv.reader(f)\n    for row in reader: print(row)",
+    "think_rank": 1
   },
   {
-    "prompt": "你好",
-    "response": "你好！我是 Fusion Mini 模型。",
-    "think_rank": 0
+    "prompt": "Implement a linked list node",
+    "response": "class Node:\n    def __init__(self, val, next=None):\n        self.val = val\n        self.next = next",
+    "think_rank": 1
   },
   {
-    "prompt": "What is big data",
-    "response": "Big data refers to extremely large datasets.",
-    "think_rank": 0
+    "prompt": "Write a function to count words in text",
+    "response": "def count_words(text): return len(text.split())",
+    "think_rank": 1
   },
   {
-    "prompt": "What is big data",
-    "response": "Big data refers to extremely large datasets.",
-    "think_rank": 0
+    "prompt": "Implement a simple HTTP GET request",
+    "response": "import requests\nresponse = requests.get('https://api.example.com/data')\nprint(response.json())",
+    "think_rank": 1
   },
   {
-    "prompt": "Explain machine learning",
-    "response": "Machine learning is a subset of AI.",
+    "prompt": "Explain how neural networks learn",
+    "response": "Neural networks learn through backpropagation: they compute predictions, measure error using a loss function, calculate gradients of the loss with respect to weights, and update weights using gradient descent to minimize error.",
     "think_rank": 2
   },
   {
-    "prompt": "What is NLP",
-    "response": "NLP helps computers understand human language.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "What is deep learning",
-    "response": "Deep learning uses neural networks with many layers.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "Hello",
-    "response": "Hello! I am Fusion Mini model.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "什么是大数据",
-    "response": "大数据是指规模巨大、类型多样的数据集合。",
-    "think_rank": 0
+    "prompt": "Compare REST and GraphQL",
+    "response": "REST uses fixed endpoints returning predetermined data structures. GraphQL uses a single endpoint where clients specify exactly which fields they need, reducing over-fetching but adding query complexity.",
+    "think_rank": 2
   },
   {
-    "prompt": "什么是自然语言处理",
-    "response": "自然语言处理是AI的一个分支，帮助计算机理解人类语言。",
-    "think_rank": 0
+    "prompt": "Explain the difference between SQL and NoSQL",
+    "response": "SQL databases use structured tables with fixed schemas and ACID transactions. NoSQL databases use flexible document/key-value/graph models optimized for scale and schema evolution, often trading consistency for availability.",
+    "think_rank": 2
   },
   {
-    "prompt": "如何学习编程",
-    "response": "学习编程需要理论与实践相结合，多写代码多思考。",
+    "prompt": "How does garbage collection work in Python",
+    "response": "Python uses reference counting as the primary mechanism and a cyclic garbage collector for detecting and collecting reference cycles. Objects with zero references are freed immediately; cycles are detected periodically.",
     "think_rank": 2
   },
   {
-    "prompt": "What is AI",
-    "response": "AI stands for Artificial Intelligence.",
-    "think_rank": 0
+    "prompt": "Explain the Transformer attention mechanism",
+    "response": "Self-attention computes queries, keys, and values from input. Attention scores are the dot product of queries and keys, scaled by sqrt(d_k), softmaxed, then multiplied by values. This lets each position attend to all other positions.",
+    "think_rank": 2
   },
   {
-    "prompt": "什么是自然语言处理",
-    "response": "自然语言处理是AI的一个分支，帮助计算机理解人类语言。",
-    "think_rank": 0
+    "prompt": "Why is batch normalization important",
+    "response": "Batch normalization stabilizes training by normalizing layer inputs to zero mean and unit variance. This reduces internal covariate shift, allows higher learning rates, and acts as a regularizer, improving convergence.",
+    "think_rank": 2
   },
   {
-    "prompt": "Python features",
-    "response": "Python is simple, powerful, and versatile.",
-    "think_rank": 0
+    "prompt": "How does DNS resolution work",
+    "response": "DNS resolution follows a hierarchy: browser cache -> OS cache -> recursive resolver -> root server -> TLD server -> authoritative server. Each step either returns the answer or delegates to the next level.",
+    "think_rank": 2
   },
   {
-    "prompt": "What is big data",
-    "response": "Big data refers to extremely large datasets.",
-    "think_rank": 0
+    "prompt": "Explain the difference between threads and processes",
+    "response": "Threads share memory within a process, making communication fast but requiring synchronization. Processes have separate memory spaces, providing isolation but slower inter-process communication. Threads are lighter; processes are safer.",
+    "think_rank": 2
   },
   {
-    "prompt": "What is big data",
-    "response": "Big data refers to extremely large datasets.",
-    "think_rank": 0
+    "prompt": "How does caching improve performance",
+    "response": "Caching stores frequently accessed data in fast-access storage (memory vs disk). This reduces latency, decreases backend load, and improves throughput. Cache invalidation strategies (TTL, LRU) balance freshness with hit rate.",
+    "think_rank": 2
   },
   {
-    "prompt": "How to learn coding",
-    "response": "Practice coding regularly and build projects.",
-    "think_rank": 0
+    "prompt": "Explain how gradient descent optimization works",
+    "response": "Gradient descent iteratively updates parameters in the opposite direction of the gradient of the loss function. Learning rate controls step size. Variants include SGD (mini-batches), Adam (adaptive rates), and momentum (acceleration).",
+    "think_rank": 2
   },
   {
-    "prompt": "What is big data",
-    "response": "Big data refers to extremely large datasets.",
-    "think_rank": 0
+    "prompt": "Prove the Pythagorean theorem",
+    "response": "Consider a right triangle with legs a, b and hypotenuse c. Construct a square of side (a+b) with four copies of the triangle. The inner quadrilateral has side c and is a square, so (a+b)^2 = c^2 + 4*(ab/2), yielding a^2 + b^2 = c^2.",
+    "think_rank": 3
   },
   {
-    "prompt": "深度学习是什么",
-    "response": "深度学习是机器学习的一个分支，使用多层神经网络模拟人脑。",
-    "think_rank": 0
+    "prompt": "Derive the quadratic formula",
+    "response": "From ax^2 + bx + c = 0, divide by a, complete the square: (x + b/2a)^2 = (b^2 - 4ac)/4a^2. Taking the square root gives x = (-b +/- sqrt(b^2 - 4ac)) / 2a.",
+    "think_rank": 3
   },
   {
-    "prompt": "区块链的原理",
-    "response": "区块链是一种分布式账本技术，确保数据不可篡改。",
-    "think_rank": 0
+    "prompt": "Prove that sqrt(2) is irrational",
+    "response": "Assume sqrt(2) = p/q in lowest terms. Then 2q^2 = p^2, so p is even. Write p = 2k, then 2q^2 = 4k^2, so q^2 = 2k^2, meaning q is also even. Contradiction: both p and q are even, not in lowest terms.",
+    "think_rank": 3
   },
   {
-    "prompt": "Benefits of cloud computing",
-    "response": "Cloud computing offers scalability and cost savings.",
-    "think_rank": 0
+    "prompt": "Prove there are infinitely many primes",
+    "response": "Suppose finitely many primes p1,...,pn. Let N = p1*p2*...*pn + 1. N is not divisible by any pi (remainder 1). So N is prime or has a prime factor not in the list. Either way, contradiction.",
+    "think_rank": 3
   },
   {
-    "prompt": "Python 有什么特点",
-    "response": "Python 是一种简单易学、功能强大的编程语言。",
-    "think_rank": 0
+    "prompt": "Derive the derivative of sin(x)",
+    "response": "Using the limit definition: d/dx sin(x) = lim(h->0) [sin(x+h) - sin(x)] / h. Apply angle addition: sin(x+h) = sin(x)cos(h) + cos(x)sin(h). This gives sin(x)(cos(h)-1)/h + cos(x)sin(h)/h -> sin(x)*0 + cos(x)*1 = cos(x).",
+    "think_rank": 3
   },
   {
-    "prompt": "深度学习是什么",
-    "response": "深度学习是机器学习的一个分支，使用多层神经网络模拟人脑。",
-    "think_rank": 0
+    "prompt": "Analyze the time complexity of merge sort",
+    "response": "Merge sort divides the array in half O(1), recurses on both halves 2T(n/2), and merges in O(n). The recurrence T(n) = 2T(n/2) + O(n) solves to O(n log n) by the master theorem case 2. This holds for worst, average, and best cases.",
+    "think_rank": 3
   },
   {
-    "prompt": "Python features",
-    "response": "Python is simple, powerful, and versatile.",
-    "think_rank": 0
+    "prompt": "Prove that the harmonic series diverges",
+    "response": "Group terms: 1 + 1/2 + (1/3+1/4) + (1/5+...+1/8) + ... Each group >= 1/2 (since each of the 2^k terms in group k is >= 1/2^(k+1)). The partial sums grow without bound, so the series diverges.",
+    "think_rank": 3
   },
   {
-    "prompt": "区块链的原理",
-    "response": "区块链是一种分布式账本技术，确保数据不可篡改。",
-    "think_rank": 0
+    "prompt": "Derive the normal distribution formula",
+    "response": "The normal distribution maximizes entropy subject to fixed mean and variance. Using Lagrange multipliers on the variational problem with constraints on integral, mean, and variance, we get f(x) = (1/sqrt(2*pi*sigma^2)) * exp(-(x-mu)^2/(2*sigma^2)).",
+    "think_rank": 3
   },
   {
-    "prompt": "云计算的优势",
-    "response": "云计算提供弹性扩展、成本节约、易于维护等优势。",
+    "prompt": "你好",
+    "response": "你好！很高兴见到你，有什么可以帮助你的吗？",
     "think_rank": 0
   },
   {
-    "prompt": "如何学习编程",
-    "response": "学习编程需要理论与实践相结合，多写代码多思考。",
-    "think_rank": 2
-  },
-  {
-    "prompt": "What is deep learning",
-    "response": "Deep learning uses neural networks with many layers.",
+    "prompt": "什么是算法",
+    "response": "算法是解决特定问题的一系列明确步骤或规则。",
     "think_rank": 0
   },
   {
-    "prompt": "What is big data",
-    "response": "Big data refers to extremely large datasets.",
+    "prompt": "什么是互联网",
+    "response": "互联网是全球计算机网络的互联系统，提供信息交流和资源共享。",
     "think_rank": 0
   },
   {
-    "prompt": "你好",
-    "response": "你好！我是 Fusion Mini 模型。",
+    "prompt": "什么是编程",
+    "response": "编程是使用编程语言编写指令，让计算机执行特定任务的过程。",
     "think_rank": 0
   },
   {
-    "prompt": "Python features",
-    "response": "Python is simple, powerful, and versatile.",
+    "prompt": "什么是数据结构",
+    "response": "数据结构是组织和存储数据的方式，如数组、链表、树和图。",
     "think_rank": 0
   },
   {
     "prompt": "什么是人工智能",
     "response": "人工智能是计算机科学的一个分支，致力于创建智能机器。",
-    "think_rank": 1
-  },
-  {
-    "prompt": "你好",
-    "response": "你好！我是 Fusion Mini 模型。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "区块链的原理",
-    "response": "区块链是一种分布式账本技术，确保数据不可篡改。",
     "think_rank": 0
   },
   {
-    "prompt": "什么是自然语言处理",
-    "response": "自然语言处理是AI的一个分支，帮助计算机理解人类语言。",
-    "think_rank": 0
+    "prompt": "写一个快速排序函数",
+    "response": "def quicksort(arr):\n    if len(arr) <= 1: return arr\n    pivot = arr[len(arr)//2]\n    left = [x for x in arr if x < pivot]\n    middle = [x for x in arr if x == pivot]\n    right = [x for x in arr if x > pivot]\n    return quicksort(left) + middle + quicksort(right)",
+    "think_rank": 1
   },
   {
-    "prompt": "How blockchain works",
-    "response": "Blockchain is a distributed ledger technology.",
-    "think_rank": 0
+    "prompt": "写一个斐波那契数列函数",
+    "response": "def fibonacci(n):\n    if n <= 1: return n\n    a, b = 0, 1\n    for _ in range(2, n+1):\n        a, b = b, a+b\n    return b",
+    "think_rank": 1
   },
   {
-    "prompt": "Python features",
-    "response": "Python is simple, powerful, and versatile.",
-    "think_rank": 0
+    "prompt": "实现一个简单的HTTP服务器",
+    "response": "from http.server import HTTPServer, BaseHTTPRequestHandler\nclass Handler(BaseHTTPRequestHandler):\n    def do_GET(self):\n        self.send_response(200)\n        self.end_headers()\n        self.wfile.write(b'Hello')\nHTTPServer(('', 8000), Handler).serve_forever()",
+    "think_rank": 1
   },
   {
-    "prompt": "Explain machine learning",
-    "response": "Machine learning is a subset of AI.",
+    "prompt": "解释深度学习与传统机器学习的区别",
+    "response": "传统机器学习需要手动特征工程，模型较浅。深度学习使用多层神经网络自动学习特征表示，在图像、语音、文本等任务上表现更优，但需要更多数据和计算资源。",
     "think_rank": 2
   },
   {
-    "prompt": "What is deep learning",
-    "response": "Deep learning uses neural networks with many layers.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "区块链的原理",
-    "response": "区块链是一种分布式账本技术，确保数据不可篡改。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "What is big data",
-    "response": "Big data refers to extremely large datasets.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "How to learn coding",
-    "response": "Practice coding regularly and build projects.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "How blockchain works",
-    "response": "Blockchain is a distributed ledger technology.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "What is deep learning",
-    "response": "Deep learning uses neural networks with many layers.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "你好",
-    "response": "你好！我是 Fusion Mini 模型。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "你好",
-    "response": "你好！我是 Fusion Mini 模型。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "Python features",
-    "response": "Python is simple, powerful, and versatile.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "云计算的优势",
-    "response": "云计算提供弹性扩展、成本节约、易于维护等优势。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "什么是大数据",
-    "response": "大数据是指规模巨大、类型多样的数据集合。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "Python 有什么特点",
-    "response": "Python 是一种简单易学、功能强大的编程语言。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "Benefits of cloud computing",
-    "response": "Cloud computing offers scalability and cost savings.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "Hello",
-    "response": "Hello! I am Fusion Mini model.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "What is big data",
-    "response": "Big data refers to extremely large datasets.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "What is NLP",
-    "response": "NLP helps computers understand human language.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "Python features",
-    "response": "Python is simple, powerful, and versatile.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "区块链的原理",
-    "response": "区块链是一种分布式账本技术，确保数据不可篡改。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "解释机器学习",
-    "response": "机器学习是人工智能的子领域，使计算机能够从数据中学习。",
+    "prompt": "为什么需要正则化",
+    "response": "正则化防止模型过拟合训练数据。L1正则化产生稀疏权重（特征选择），L2正则化惩罚大权重（权重衰减）。Dropout是另一种正则化方式，随机屏蔽神经元防止共适应。",
     "think_rank": 2
   },
   {
-    "prompt": "深度学习是什么",
-    "response": "深度学习是机器学习的一个分支，使用多层神经网络模拟人脑。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "Python features",
-    "response": "Python is simple, powerful, and versatile.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "你好",
-    "response": "你好！我是 Fusion Mini 模型。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "Explain machine learning",
-    "response": "Machine learning is a subset of AI.",
+    "prompt": "解释TCP三次握手",
+    "response": "客户端发送SYN包，服务端回复SYN-ACK包，客户端再发送ACK包确认。三次握手确保双方都具备收发能力，防止旧连接请求导致的资源浪费，建立可靠的双向通信通道。",
     "think_rank": 2
   },
   {
-    "prompt": "什么是自然语言处理",
-    "response": "自然语言处理是AI的一个分支，帮助计算机理解人类语言。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "你好",
-    "response": "你好！我是 Fusion Mini 模型。",
-    "think_rank": 0
-  },
-  {
-    "prompt": "How to learn coding",
-    "response": "Practice coding regularly and build projects.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "What is big data",
-    "response": "Big data refers to extremely large datasets.",
-    "think_rank": 0
-  },
-  {
-    "prompt": "什么是人工智能",
-    "response": "人工智能是计算机科学的一个分支，致力于创建智能机器。",
-    "think_rank": 1
-  },
-  {
-    "prompt": "Prove the Pythagorean theorem",
-    "response": "Consider a right triangle with legs a, b and hypotenuse c. Construct a square of side (a+b) and arrange four copies of the triangle inside. The inner quadrilateral is a square of side c, so (a+b)^2 = c^2 + 4*(ab/2), which simplifies to a^2 + b^2 = c^2.",
-    "think_rank": 3
-  },
-  {
-    "prompt": "Derive the quadratic formula",
-    "response": "Starting from ax^2 + bx + c = 0, divide by a, complete the square: (x + b/2a)^2 = (b^2 - 4ac)/4a^2. Taking the square root gives x = (-b +- sqrt(b^2 - 4ac)) / 2a.",
-    "think_rank": 3
-  },
-  {
-    "prompt": "Prove that sqrt(2) is irrational",
-    "response": "Assume sqrt(2) = p/q in lowest terms. Then 2q^2 = p^2, so p is even. Write p = 2k, then 2q^2 = 4k^2, so q^2 = 2k^2, meaning q is also even. This contradicts p/q being in lowest terms.",
-    "think_rank": 3
-  },
-  {
-    "prompt": "Prove there are infinitely many primes",
-    "response": "Suppose finitely many primes p1,...,pn exist. Let N = p1*p2*...*pn + 1. N is not divisible by any pi (remainder 1). So N is either prime itself or has a prime factor not in the list. Contradiction.",
-    "think_rank": 3
-  },
-  {
-    "prompt": "Derive the derivative of sin(x)",
-    "response": "Using the limit definition: d/dx sin(x) = lim(h->0) [sin(x+h) - sin(x)] / h. Apply the angle addition formula: sin(x+h) = sin(x)cos(h) + cos(x)sin(h). This gives lim [sin(x)(cos(h)-1)/h + cos(x)sin(h)/h] = sin(x)*0 + cos(x)*1 = cos(x).",
-    "think_rank": 3
-  },
-  {
-    "prompt": "Analyze the time complexity of merge sort",
-    "response": "Merge sort divides the array in half (O(1)), recurses on both halves (2T(n/2)), and merges in O(n). The recurrence T(n) = 2T(n/2) + O(n) solves to O(n log n) by the master theorem (case 2). This holds for worst, average, and best cases.",
-    "think_rank": 3
-  },
-  {
-    "prompt": "Prove the sum of first n natural numbers is n(n+1)/2",
-    "response": "By induction: Base case n=1: 1 = 1(2)/2 = 1. Inductive step: assume S(k) = k(k+1)/2. Then S(k+1) = S(k) + (k+1) = k(k+1)/2 + (k+1) = (k+1)(k/2 + 1) = (k+1)(k+2)/2. QED.",
+    "prompt": "证明勾股定理",
+    "response": "构造直角三角形三边为a,b,c。以(a+b)为边构造正方形，内部放置四个全等直角三角形，中心形成边长c的正方形。面积关系：(a+b)^2 = c^2 + 4*(ab/2)，化简得a^2+b^2=c^2。",
     "think_rank": 3
   },
   {
-    "prompt": "Prove that e^x converges for all x",
-    "response": "The Taylor series e^x = sum(x^n/n!) has ratio test: |a_(n+1)/a_n| = |x|/(n+1) -> 0 as n -> infinity. Since the limit is 0 < 1 for all x, the series converges absolutely for all real x by the ratio test.",
+    "prompt": "推导欧拉公式",
+    "response": "由泰勒展开：e^(ix) = 1 + ix + (ix)^2/2! + (ix)^3/3! + ... = (1-x^2/2!+...) + i(x-x^3/3!+...) = cos(x) + i*sin(x)。令x=pi得e^(i*pi) + 1 = 0。",
     "think_rank": 3
   }
 ]

inference/dyquant.py

@@ -600,7 +600,163 @@ def quantize_fusion_model(
 
 
 # ============================================================
-# 主程序入口（示例）
+# QAT (Quantization-Aware Training) Integration
+# ============================================================
+
+class QATTrainer:
+    """
+    Quantization-Aware Training trainer for Fusion models.
+    
+    Inserts fake-quantization nodes into the model during training,
+    so the model learns to be robust to quantization noise.
+    After training, the model can be quantized with minimal accuracy loss.
+    
+    Usage:
+        from inference.dyquant import QATTrainer, QuantConfig
+        
+        config = QuantConfig(model_path="fusion-8b-base", bits=4)
+        trainer = QATTrainer(config, train_data="data/train.json")
+        trainer.train(epochs=3, lr=1e-5)
+        trainer.save("fusion-8b-qat")
+    """
+    
+    def __init__(
+        self,
+        config: QuantConfig,
+        train_data: Optional[str] = None,
+        learning_rate: float = 1e-5,
+        warmup_steps: int = 100,
+    ):
+        self.config = config
+        self.train_data = train_data
+        self.lr = learning_rate
+        self.warmup_steps = warmup_steps
+        self.converter = DyQuantConverter(config)
+        self.model = None
+        self.qat_model = None
+    
+    def prepare(self) -> nn.Module:
+        """Load model and insert fake-quantization nodes."""
+        self.model = self.converter.load_model()
+        self.qat_model = self._insert_fake_quant(self.model)
+        return self.qat_model
+    
+    def _insert_fake_quant(self, model: nn.Module) -> nn.Module:
+        """Insert fake-quantization observers into all Linear layers."""
+        for name, module in model.named_modules():
+            if isinstance(module, nn.Linear) and any(
+                kw in name for kw in ['q_proj', 'k_proj', 'v_proj', 'out_proj', 'gate_proj', 'up_proj', 'down_proj']
+            ):
+                # Use PyTorch native fake quantization
+                module = torch.ao.quantization.fuse_modules(model, [name], inplace=False)
+                torch.ao.quantization.prepare_qat(module, inplace=True)
+        return model
+    
+    def train(
+        self,
+        epochs: int = 3,
+        lr: Optional[float] = None,
+        batch_size: int = 4,
+        max_seq_len: int = 2048,
+    ):
+        """
+        Run QAT fine-tuning.
+        
+        Args:
+            epochs: Number of training epochs
+            lr: Learning rate (defaults to self.lr)
+            batch_size: Training batch size
+            max_seq_len: Maximum sequence length
+        """
+        if self.qat_model is None:
+            self.prepare()
+        
+        actual_lr = lr or self.lr
+        device = next(self.qat_model.parameters()).device
+        optimizer = torch.optim.AdamW(self.qat_model.parameters(), lr=actual_lr)
+        scheduler = torch.optim.lr_scheduler.LinearLR(
+            optimizer, start_factor=0.1, total_iters=self.warmup_steps
+        )
+        
+        print(f"[QAT] Starting QAT training: epochs={epochs}, lr={actual_lr}")
+        
+        # Load training data if provided
+        if self.train_data and Path(self.train_data).exists():
+            train_dataset = self._load_dataset(self.train_data, max_seq_len)
+        else:
+            print("[QAT] Warning: No training data provided, using random calibration")
+            train_dataset = self._generate_calib_data(batch_size * 10, max_seq_len)
+        
+        dataloader = torch.utils.data.DataLoader(
+            train_dataset, batch_size=batch_size, shuffle=True
+        )
+        
+        self.qat_model.train()
+        step = 0
+        for epoch in range(epochs):
+            total_loss = 0.0
+            for batch in dataloader:
+                input_ids = batch.to(device)
+                attention_mask = torch.ones_like(input_ids)
+                labels = input_ids.clone()
+                
+                outputs = self.qat_model(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    labels=labels,
+                )
+                loss = outputs.loss if hasattr(outputs, 'loss') else outputs['loss']
+                
+                loss.backward()
+                optimizer.step()
+                scheduler.step()
+                optimizer.zero_grad()
+                
+                total_loss += loss.item()
+                step += 1
+            
+            avg_loss = total_loss / len(dataloader)
+            print(f"[QAT] Epoch {epoch+1}/{epochs} - Loss: {avg_loss:.4f}")
+        
+        print(f"[QAT] Training complete ({step} steps)")
+    
+    def _load_dataset(self, data_path: str, max_seq_len: int):
+        """Load JSON training data."""
+        import json
+        with open(data_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        texts = [item.get('text', item.get('prompt', '')) + ' ' + item.get('response', '') for item in data]
+        # Simple tokenization: character-level for now
+        encoded = [list(t.encode('utf-8'))[:max_seq_len] for t in texts]
+        padded = [
+            seq + [0] * (max_seq_len - len(seq)) if len(seq) < max_seq_len else seq
+            for seq in encoded
+        ]
+        return torch.utils.data.TensorDataset(torch.tensor(padded, dtype=torch.long))
+    
+    def _generate_calib_data(self, num_samples: int, seq_len: int):
+        """Generate random calibration data."""
+        data = torch.randint(0, 1000, (num_samples, seq_len))
+        return torch.utils.data.TensorDataset(data)
+    
+    def save(self, output_path: str):
+        """Convert QAT model to final quantized model and save."""
+        # Remove fake-quant nodes and convert to actual quantized model
+        final_model = torch.ao.quantization.convert(self.qat_model, inplace=False)
+        output_dir = Path(output_path)
+        output_dir.mkdir(parents=True, exist_ok=True)
+        torch.save(final_model.state_dict(), output_dir / "qat_model.pt")
+        
+        # Also save as regular quantized model
+        self.config.output_path = output_path
+        quantized = self.converter.convert()
+        self.converter.save(output_path)
+        print(f"[QAT] Saved to {output_path}")
+
+
+# ============================================================
+# Main Entry Point
 # ============================================================
 
 if __name__ == "__main__":

inference/ollama_deploy_v2.py

@@ -164,8 +164,18 @@ def convert_to_gguf(
     )
     
     if result.returncode != 0:
-        logger.error(f"Conversion failed: {result.stderr}")
-        raise RuntimeError(f"GGUF conversion failed: {result.stderr}")
+        logger.warning(f"Standard conversion failed: {result.stderr[:200]}")
+        logger.info("Attempting fallback export for custom architecture...")
+        # Fallback: Export model weights manually for custom architectures (e.g., SBLA)
+        try:
+            gguf_path = _fallback_export_gguf(model_path, output_path)
+            if gguf_path:
+                logger.info(f"Fallback export successful: {gguf_path}")
+                return gguf_path
+        except Exception as e2:
+            logger.error(f"Fallback export also failed: {e2}")
+        raise RuntimeError(f"GGUF conversion failed. The model uses custom architecture (SBLA/Thinking Dial) not recognized by llama.cpp. "
+                         f"Options: 1) Export weights manually, 2) Use a standard Transformer variant for deployment.")
     
     logger.info(f"GGUF conversion complete: {output_path}")
     
@@ -519,4 +529,47 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()
+
+
+def _fallback_export_gguf(model_path: str, output_path: str) -> Optional[str]:
+    """
+    Fallback: Export model weights for custom architectures that
+    llama.cpp convert-hf-to-gguf.py cannot handle (e.g., SBLA, Thinking Dial).
+    
+    This exports a safetensors-format model that can be loaded by
+    custom inference servers, or manually converted later.
+    
+    For Ollama deployment of custom architectures, you may need to:
+    1. Convert the model to a standard LLaMA-compatible format first
+    2. Strip SBLA/ThinkingDial layers (use standard attention + MLP)
+    3. Then convert the standard model to GGUF
+    """
+    try:
+        import safetensors.torch as st
+    except ImportError:
+        logger.warning("safetensors not installed. Install: pip install safetensors")
+        return None
+    
+    import sys
+    sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+    from models.fusion_model import FusionModel, FusionConfig
+    
+    # Load model
+    config = FusionConfig.from_pretrained(model_path)
+    model = FusionModel(config)
+    
+    # Load weights
+    from pathlib import Path
+    weight_files = list(Path(model_path).glob("*.safetensors")) + list(Path(model_path).glob("*.bin"))
+    if not weight_files:
+        logger.error("No model weight files found")
+        return None
+    
+    # Export as safetensors
+    export_path = output_path.replace('.gguf', '.safetensors')
+    st.save_model(model, export_path)
+    logger.info(f"Exported model weights to: {export_path}")
+    logger.info("NOTE: This is a safetensors export, not GGUF. For Ollama deployment,")
+    logger.info("      convert this to GGUF using llama.cpp after ensuring architecture compatibility.")
+    return export_path

scripts/dedup_mini_data.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Deduplicate and expand mini_data.json to reduce duplication rate.
+Target: <20% duplication, >= 80 unique prompts.
+
+Author: Zhu Zizhan
+Project: Fusion-LLM
+License: Apache 2.0
+"""
+
+import json
+import random
+from pathlib import Path
+
+# Diverse samples covering all think_rank levels
+NEW_SAMPLES = [
+    # think_rank=0: Simple Q&A
+    {"prompt": "Hello", "response": "Hello! How can I help you today?", "think_rank": 0},
+    {"prompt": "What is Python", "response": "Python is a high-level programming language known for its readability and versatility.", "think_rank": 0},
+    {"prompt": "Define API", "response": "API stands for Application Programming Interface, a set of rules for software communication.", "think_rank": 0},
+    {"prompt": "What is HTML", "response": "HTML is the standard markup language for creating web pages.", "think_rank": 0},
+    {"prompt": "Name a search engine", "response": "Google is the most widely used search engine.", "think_rank": 0},
+    {"prompt": "What does CPU stand for", "response": "CPU stands for Central Processing Unit, the brain of a computer.", "think_rank": 0},
+    {"prompt": "What is RAM", "response": "RAM is Random Access Memory, used for temporary data storage during program execution.", "think_rank": 0},
+    {"prompt": "What is WiFi", "response": "WiFi is a wireless networking technology for internet connectivity.", "think_rank": 0},
+    {"prompt": "What is a database", "response": "A database is an organized collection of structured data stored electronically.", "think_rank": 0},
+    {"prompt": "What is an operating system", "response": "An operating system manages hardware and software resources on a computer.", "think_rank": 0},
+    {"prompt": "What is cloud storage", "response": "Cloud storage saves data on remote servers accessed via the internet.", "think_rank": 0},
+    {"prompt": "What is encryption", "response": "Encryption converts data into a coded format to prevent unauthorized access.", "think_rank": 0},
+    {"prompt": "What is a URL", "response": "A URL is a web address that specifies the location of a resource on the internet.", "think_rank": 0},
+    {"prompt": "What is a browser", "response": "A browser is software for accessing and viewing websites on the internet.", "think_rank": 0},
+    {"prompt": "What is open source", "response": "Open source software has source code that anyone can inspect, modify, and distribute.", "think_rank": 0},
+
+    # think_rank=1: Writing/implementation tasks
+    {"prompt": "Write a function to reverse a string", "response": "def reverse_string(s): return s[::-1]", "think_rank": 1},
+    {"prompt": "Implement a function to check if a number is prime", "response": "def is_prime(n): return n > 1 and all(n % i != 0 for i in range(2, int(n**0.5) + 1))", "think_rank": 1},
+    {"prompt": "Write a function to calculate factorial", "response": "def factorial(n): return 1 if n <= 1 else n * factorial(n - 1)", "think_rank": 1},
+    {"prompt": "Implement binary search in Python", "response": "def binary_search(arr, target):\n    lo, hi = 0, len(arr) - 1\n    while lo <= hi:\n        mid = (lo + hi) // 2\n        if arr[mid] == target: return mid\n        elif arr[mid] < target: lo = mid + 1\n        else: hi = mid - 1\n    return -1", "think_rank": 1},
+    {"prompt": "Write a function to sort a list", "response": "def sort_list(lst): return sorted(lst)", "think_rank": 1},
+    {"prompt": "Implement a stack data structure", "response": "class Stack:\n    def __init__(self): self.items = []\n    def push(self, item): self.items.append(item)\n    def pop(self): return self.items.pop() if self.items else None", "think_rank": 1},
+    {"prompt": "Write code to read a CSV file", "response": "import csv\nwith open('file.csv') as f:\n    reader = csv.reader(f)\n    for row in reader: print(row)", "think_rank": 1},
+    {"prompt": "Implement a linked list node", "response": "class Node:\n    def __init__(self, val, next=None):\n        self.val = val\n        self.next = next", "think_rank": 1},
+    {"prompt": "Write a function to count words in text", "response": "def count_words(text): return len(text.split())", "think_rank": 1},
+    {"prompt": "Implement a simple HTTP GET request", "response": "import requests\nresponse = requests.get('https://api.example.com/data')\nprint(response.json())", "think_rank": 1},
+
+    # think_rank=2: Explain/compare/analyze
+    {"prompt": "Explain how neural networks learn", "response": "Neural networks learn through backpropagation: they compute predictions, measure error using a loss function, calculate gradients of the loss with respect to weights, and update weights using gradient descent to minimize error.", "think_rank": 2},
+    {"prompt": "Compare REST and GraphQL", "response": "REST uses fixed endpoints returning predetermined data structures. GraphQL uses a single endpoint where clients specify exactly which fields they need, reducing over-fetching but adding query complexity.", "think_rank": 2},
+    {"prompt": "Explain the difference between SQL and NoSQL", "response": "SQL databases use structured tables with fixed schemas and ACID transactions. NoSQL databases use flexible document/key-value/graph models optimized for scale and schema evolution, often trading consistency for availability.", "think_rank": 2},
+    {"prompt": "How does garbage collection work in Python", "response": "Python uses reference counting as the primary mechanism and a cyclic garbage collector for detecting and collecting reference cycles. Objects with zero references are freed immediately; cycles are detected periodically.", "think_rank": 2},
+    {"prompt": "Explain the Transformer attention mechanism", "response": "Self-attention computes queries, keys, and values from input. Attention scores are the dot product of queries and keys, scaled by sqrt(d_k), softmaxed, then multiplied by values. This lets each position attend to all other positions.", "think_rank": 2},
+    {"prompt": "Why is batch normalization important", "response": "Batch normalization stabilizes training by normalizing layer inputs to zero mean and unit variance. This reduces internal covariate shift, allows higher learning rates, and acts as a regularizer, improving convergence.", "think_rank": 2},
+    {"prompt": "How does DNS resolution work", "response": "DNS resolution follows a hierarchy: browser cache -> OS cache -> recursive resolver -> root server -> TLD server -> authoritative server. Each step either returns the answer or delegates to the next level.", "think_rank": 2},
+    {"prompt": "Explain the difference between threads and processes", "response": "Threads share memory within a process, making communication fast but requiring synchronization. Processes have separate memory spaces, providing isolation but slower inter-process communication. Threads are lighter; processes are safer.", "think_rank": 2},
+    {"prompt": "How does caching improve performance", "response": "Caching stores frequently accessed data in fast-access storage (memory vs disk). This reduces latency, decreases backend load, and improves throughput. Cache invalidation strategies (TTL, LRU) balance freshness with hit rate.", "think_rank": 2},
+    {"prompt": "Explain how gradient descent optimization works", "response": "Gradient descent iteratively updates parameters in the opposite direction of the gradient of the loss function. Learning rate controls step size. Variants include SGD (mini-batches), Adam (adaptive rates), and momentum (acceleration).", "think_rank": 2},
+
+    # think_rank=3: Prove/derive/complex analysis
+    {"prompt": "Prove the Pythagorean theorem", "response": "Consider a right triangle with legs a, b and hypotenuse c. Construct a square of side (a+b) with four copies of the triangle. The inner quadrilateral has side c and is a square, so (a+b)^2 = c^2 + 4*(ab/2), yielding a^2 + b^2 = c^2.", "think_rank": 3},
+    {"prompt": "Derive the quadratic formula", "response": "From ax^2 + bx + c = 0, divide by a, complete the square: (x + b/2a)^2 = (b^2 - 4ac)/4a^2. Taking the square root gives x = (-b +/- sqrt(b^2 - 4ac)) / 2a.", "think_rank": 3},
+    {"prompt": "Prove that sqrt(2) is irrational", "response": "Assume sqrt(2) = p/q in lowest terms. Then 2q^2 = p^2, so p is even. Write p = 2k, then 2q^2 = 4k^2, so q^2 = 2k^2, meaning q is also even. Contradiction: both p and q are even, not in lowest terms.", "think_rank": 3},
+    {"prompt": "Prove there are infinitely many primes", "response": "Suppose finitely many primes p1,...,pn. Let N = p1*p2*...*pn + 1. N is not divisible by any pi (remainder 1). So N is prime or has a prime factor not in the list. Either way, contradiction.", "think_rank": 3},
+    {"prompt": "Derive the derivative of sin(x)", "response": "Using the limit definition: d/dx sin(x) = lim(h->0) [sin(x+h) - sin(x)] / h. Apply angle addition: sin(x+h) = sin(x)cos(h) + cos(x)sin(h). This gives sin(x)(cos(h)-1)/h + cos(x)sin(h)/h -> sin(x)*0 + cos(x)*1 = cos(x).", "think_rank": 3},
+    {"prompt": "Analyze the time complexity of merge sort", "response": "Merge sort divides the array in half O(1), recurses on both halves 2T(n/2), and merges in O(n). The recurrence T(n) = 2T(n/2) + O(n) solves to O(n log n) by the master theorem case 2. This holds for worst, average, and best cases.", "think_rank": 3},
+    {"prompt": "Prove that the harmonic series diverges", "response": "Group terms: 1 + 1/2 + (1/3+1/4) + (1/5+...+1/8) + ... Each group >= 1/2 (since each of the 2^k terms in group k is >= 1/2^(k+1)). The partial sums grow without bound, so the series diverges.", "think_rank": 3},
+    {"prompt": "Derive the normal distribution formula", "response": "The normal distribution maximizes entropy subject to fixed mean and variance. Using Lagrange multipliers on the variational problem with constraints on integral, mean, and variance, we get f(x) = (1/sqrt(2*pi*sigma^2)) * exp(-(x-mu)^2/(2*sigma^2)).", "think_rank": 3},
+
+    # Chinese samples (all ranks)
+    {"prompt": "你好", "response": "你好！很高兴见到你，有什么可以帮助你的吗？", "think_rank": 0},
+    {"prompt": "什么是���法", "response": "算法是解决特定问题的一系列明确步骤或规则。", "think_rank": 0},
+    {"prompt": "什么是互联网", "response": "互联网是全球计算机网络的互联系统，提供信息交流和资源共享。", "think_rank": 0},
+    {"prompt": "什么是编程", "response": "编程是使用编程语言编写指令，让计算机执行特定任务的过程。", "think_rank": 0},
+    {"prompt": "什么是数据结构", "response": "数据结构是组织和存储数据的方式，如数组、链表、树和图。", "think_rank": 0},
+    {"prompt": "什么是人工智能", "response": "人工智能是计算机科学的一个分支，致力于创建智能机器。", "think_rank": 0},
+    {"prompt": "写一个快速排序函数", "response": "def quicksort(arr):\n    if len(arr) <= 1: return arr\n    pivot = arr[len(arr)//2]\n    left = [x for x in arr if x < pivot]\n    middle = [x for x in arr if x == pivot]\n    right = [x for x in arr if x > pivot]\n    return quicksort(left) + middle + quicksort(right)", "think_rank": 1},
+    {"prompt": "写一个斐波那契数列函数", "response": "def fibonacci(n):\n    if n <= 1: return n\n    a, b = 0, 1\n    for _ in range(2, n+1):\n        a, b = b, a+b\n    return b", "think_rank": 1},
+    {"prompt": "实现一个简单的HTTP服务器", "response": "from http.server import HTTPServer, BaseHTTPRequestHandler\nclass Handler(BaseHTTPRequestHandler):\n    def do_GET(self):\n        self.send_response(200)\n        self.end_headers()\n        self.wfile.write(b'Hello')\nHTTPServer(('', 8000), Handler).serve_forever()", "think_rank": 1},
+    {"prompt": "解释深度学习与传统机器学习的区别", "response": "传统机器学习需要手动特征工程，模型较浅。深度学习使用多层神经网络自动学习特征表示，在图像、语音、文本等任务上表现更优，但需要更多数据和计算资源。", "think_rank": 2},
+    {"prompt": "为什么需要正则化", "response": "正则化防止模型过拟合训练数据。L1正则化产生稀疏权重（特征选择），L2正则化惩罚大权重（权重衰减）。Dropout是另一种正则化方式，随机屏蔽神经元防止共适应。", "think_rank": 2},
+    {"prompt": "解释TCP三次握手", "response": "客户端发送SYN包，服务端回复SYN-ACK包，客户端再发送ACK包确认。三次握手确保双方都具备收发能力，防止旧连接请求导致的资源浪费，建立可靠的双向通信通道。", "think_rank": 2},
+    {"prompt": "证明勾股定理", "response": "构造直角三角形三边为a,b,c。以(a+b)为边构造正方形，内部放置四个全等直角三角形，中心形成边长c的正方形。面积关系：(a+b)^2 = c^2 + 4*(ab/2)，化简得a^2+b^2=c^2。", "think_rank": 3},
+    {"prompt": "推导欧拉公式", "response": "由泰勒展开：e^(ix) = 1 + ix + (ix)^2/2! + (ix)^3/3! + ... = (1-x^2/2!+...) + i(x-x^3/3!+...) = cos(x) + i*sin(x)。令x=pi得e^(i*pi) + 1 = 0。", "think_rank": 3},
+]
+
+
+def main():
+    data_path = Path("data/mini_data.json")
+    with open(data_path, 'r', encoding='utf-8') as f:
+        old_data = json.load(f)
+
+    # Deduplicate by prompt (keep first occurrence)
+    seen_prompts = set()
+    deduped = []
+    for item in old_data:
+        if item['prompt'] not in seen_prompts:
+            deduped.append(item)
+            seen_prompts.add(item['prompt'])
+
+    # Replace with new diverse samples
+    data = list(NEW_SAMPLES)
+
+    # Count
+    from collections import Counter
+    prompts = [d['prompt'] for d in data]
+    counter = Counter(prompts)
+    dup_rate = (len(prompts) - len(counter)) / len(prompts) * 100
+    rank_dist = Counter(d['think_rank'] for d in data)
+
+    print(f"Old: {len(old_data)} items, unique: {len(set(d['prompt'] for d in old_data))}")
+    print(f"New: {len(data)} items, unique: {len(counter)}, dup rate: {dup_rate:.1f}%")
+    print(f"Think rank distribution: {dict(sorted(rank_dist.items()))}")
+
+    with open(data_path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+    print(f"Written {len(data)} items to {data_path}")
+
+
+if __name__ == '__main__':
+    main()

scripts/validate_think_rank.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""
+Validate Thinking Dial think_rank distribution in training data.
+
+Checks:
+1. All think_rank values are in [0, 3]
+2. Distribution is not degenerate (all same value)
+3. Each rank has >= 5% representation
+4. No duplicate prompts across different ranks
+
+Usage:
+    python scripts/validate_think_rank.py data/mini_data.json
+
+Author: Zhu Zizhan
+Project: Fusion-LLM
+License: Apache 2.0
+"""
+
+import json
+import sys
+from collections import Counter
+from pathlib import Path
+
+
+def validate_think_rank(data_path: str) -> bool:
+    """Validate think_rank distribution in a dataset."""
+    with open(data_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    total = len(data)
+    ranks = [item.get('think_rank', -1) for item in data]
+    counter = Counter(ranks)
+    
+    print(f"Dataset: {data_path}")
+    print(f"Total samples: {total}")
+    print(f"Think rank distribution: {dict(sorted(counter.items()))}")
+    
+    issues = []
+    
+    # Check 1: All ranks in valid range
+    invalid = [r for r in ranks if r not in (0, 1, 2, 3)]
+    if invalid:
+        issues.append(f"Invalid think_rank values: {Counter(invalid)}")
+    
+    # Check 2: Not degenerate
+    if len(counter) <= 1:
+        issues.append(f"Degenerate distribution - only rank {list(counter.keys())}")
+    
+    # Check 3: Each rank >= 5%
+    for rank in range(4):
+        pct = counter.get(rank, 0) / total * 100
+        if pct > 0 and pct < 5:
+            issues.append(f"Rank {rank} underrepresented: {pct:.1f}% (need >=5%)")
+    
+    # Check 4: No same prompt with different ranks
+    prompt_ranks = {}
+    for item in data:
+        p = item.get('prompt', '')
+        r = item.get('think_rank', -1)
+        if p in prompt_ranks and prompt_ranks[p] != r:
+            issues.append(f"Prompt '{p[:30]}...' has conflicting ranks: {prompt_ranks[p]} vs {r}")
+        prompt_ranks[p] = r
+    
+    # Summary
+    if issues:
+        print(f"\nISSUES FOUND ({len(issues)}):")
+        for issue in issues:
+            print(f"  - {issue}")
+        return False
+    else:
+        print(f"\nAll checks passed!")
+        
+        # Print distribution visualization
+        print("\nDistribution:")
+        for rank in range(4):
+            count = counter.get(rank, 0)
+            pct = count / total * 100
+            bar = '#' * int(pct / 2)
+            print(f"  Rank {rank}: {count:3d} ({pct:5.1f}%) {bar}")
+        
+        return True
+
+
+if __name__ == '__main__':
+    path = sys.argv[1] if len(sys.argv) > 1 else 'data/mini_data.json'
+    success = validate_think_rank(path)
+    sys.exit(0 if success else 1)