Create README.md

README.md

@@ -0,0 +1,243 @@
+---
+base_model:
+- inclusionAI/Ling-flash-2.0
+---
+
+## Model Details
+
+This model is a mixed gguf q2ks format of  [MiniMaxAI/MiniMax-M2](https://huggingface.co/MiniMaxAI/MiniMax-M2)  generated by [intel/auto-round](https://github.com/intel/auto-round) algorithm.  Embedding layer and lm-head layer are fallback to 8 bits and non expert layers are fallback to 4 bits. Please refer to Section `Generate the model` for more details.
+
+Please follow the license of the original model.
+
+## How To Use
+
+Llamacpp inference.
+
+~~~bash
+/llama-cli -hf Intel/MiniMax-M2-gguf-q2ks-mixed-AutoRound --jinja
+~~~
+
+~~~bash
+> Write a quick sort algorithm.
+The user wants me to write a quick sort algorithm. I should write a clear and concise explanation of how quicksort works, followed by a code example in a commonly used language like Python or JavaScript. I'll make sure to explain the key concepts like the pivot, partitioning, and recursion.
+</think>
+
+I'll provide a clear explanation of the Quick Sort algorithm followed by a code implementation.
+
+## Quick Sort Algorithm Overview
+
+Quick Sort is a divide-and-conquer sorting algorithm that works by:
+1. **Choosing a pivot** element from the array
+2. **Partitioning** the array so elements smaller than the pivot come before it, and larger elements come after
+3. **Recursively** sorting the sub-arrays formed by dividing the array around the pivot
+
+## Key Concepts:
+- **Pivot**: The reference element used for partitioning
+- **Partitioning**: Rearranging elements so the pivot ends up in its correct final position
+- **Time Complexity**: Average O(n log n), Worst O(n²) when pivot selection is poor
+
+## Python Implementation
+
+```python
+def quick_sort(arr, low, high):
+    if low < high:
+        # Step 1: Partition the array and get pivot index
+        pivot_index = partition(arr, low, high)
+
+        # Step 2: Recursively sort elements before and after partition
+        quick_sort(arr, low, pivot_index - 1)  # Sort left sub-array
+        quick_sort(arr, pivot_index + 1, high)  # Sort right sub-array
+
+def partition(arr, low, high):
+    # Choose the rightmost element as pivot
+    pivot = arr[high]
+
+    # Index of smaller element
+    i = low - 1
+
+    for j in range(low, high):
+        # If current element is smaller than or equal to pivot
+        if arr[j] <= pivot:
+            i += 1
+            # Swap arr[i] and arr[j]
+            arr[i], arr[j] = arr[j], arr[i]
+
+    # Move pivot to its correct position
+    arr[i + 1], arr[high] = arr[high], arr[i + 1]
+    return i + 1
+
+# Example usage and helper function
+def quick_sort_wrapper(arr):
+    """Helper function that sorts the entire array"""
+    if len(arr) <= 1:
+        return arr
+    quick_sort(arr, 0, len(arr) - 1)
+    return arr
+
+# Example usage
+if __name__ == "__main__":
+    # Test array
+    data = [10, 7, 8, 9, 1, 5]
+    print(f"Original array: {data}")
+
+    sorted_data = quick_sort_wrapper(data)
+    print(f"Sorted array: {sorted_data}")
+
+    # Another example
+    test_arr = [64, 34, 25, 12, 22, 11, 90]
+    print(f"Original: {test_arr}")
+    quick_sort_wrapper(test_arr)
+    print(f"Sorted: {test_arr}")
+```
+
+## JavaScript Implementation
+
+```javascript
+function quickSort(arr, low = 0, high = arr.length - 1) {
+    if (low < high) {
+        // Partition and get pivot index
+        const pivotIndex = partition(arr, low, high);
+
+        // Recursively sort elements before and after partition
+        quickSort(arr, low, pivotIndex - 1);
+        quickSort(arr, pivotIndex + 1, high);
+    }
+    return arr;
+}
+
+function partition(arr, low, high) {
+    // Choose the rightmost element as pivot
+    const pivot = arr[high];
+
+    // Index of smaller element
+    let i = low - 1;
+
+    for (let j = low; j < high; j++) {
+        // If current element is smaller than or equal to pivot
+        if (arr[j] <= pivot) {
+            i++;
+            // Swap arr[i] and arr[j]
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+        }
+    }
+
+    // Move pivot to its correct position
+    [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
+    return i + 1;
+}
+
+// Example usage
+const data = [10, 7, 8, 9, 1, 5];
+console.log("Original array:", data);
+
+quickSort(data);
+console.log("Sorted array:", data);
+```
+
+## Alternative: Lomuto Partition Scheme
+
+For a simpler implementation, here's the Lomuto partition scheme:
+
+```python
+def quick_sort_lomuto(arr, low, high):
+    if low < high:
+        # Partition index
+        j = partition_lomuto(arr, low, high)
+        quick_sort_lomuto(arr, low, j - 1)
+        quick_sort_lomuto(arr, j + 1, high)
+
+def partition_lomuto(arr, low, high):
+    pivot = arr[high]
+    i = low
+
+    for k in range(low, high):
+        if arr[k] < pivot:
+            arr[i], arr[k] = arr[k], arr[i]
+            i += 1
+
+    arr[i], arr[high] = arr[high], arr[i]
+    return i
+
+# Simple usage
+def simple_quick_sort(arr):
+    quick_sort_lomuto(arr, 0, len(arr) - 1)
+    return arr
+```
+
+
+## Advantages and Disadvantages
+
+**Advantages:**
+- Average-case O(n log n) time complexity
+- In-place sorting (uses minimal extra memory)
+- Cache-friendly due to locality of reference
+
+**Disadvantages:**
+- Worst-case O(n²) time complexity (when array is already sorted)
+- Not stable (doesn't preserve order of equal elements)
+- Performance depends heavily on pivot selection
+
+## Tips for Better Performance
+1. **Choose pivot wisely**: Random pivot or median-of-three method
+2. **Handle small arrays**: Use insertion sort for small sub-arrays (typically < 10 elements)
+3. **Randomize input**: Shuffle before sorting to avoid worst-case scenarios
+
+The Quick Sort algorithm is widely used due to its excellent average-case performance and space efficiency.
+
+
+~~~
+
+
+
+### Generate the model
+
+Here is the sample command to reproduce the model
+
+```python
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from auto_round import AutoRound
+
+model_name = "MiniMaxAI/MiniMax-M2"
+
+model = AutoModelForCausalLM.from_pretrained(model_name,
+                                             device_map="cpu", torch_dtype="auto")
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+layer_config = {}
+for n, m in model.named_modules():
+    if n == "lm_head" or isinstance(m,torch.nn.Embedding):
+        layer_config[n] = {"bits": 8}
+    elif isinstance(m, torch.nn.Linear) and (not "expert" in n or "shared_experts" in n) and n != "lm_head":
+        layer_config[n] = {"bits": 4}
+
+autoround = AutoRound(model, tokenizer, iters=0, layer_config=layer_config, nsamples=512, disable_opt_rtn=False)
+autoround.quantize_and_save("tmp_autoround", format="gguf:q2_k_s")
+
+
+```
+
+
+
+## Ethical Considerations and Limitations
+
+The model can produce factually incorrect output, and should not be relied on to produce factually accurate information. Because of the limitations of the pretrained model and the finetuning datasets, it is possible that this model could generate lewd, biased or otherwise offensive outputs.
+
+Therefore, before deploying any applications of the model, developers should perform safety testing.
+
+## Caveats and Recommendations
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model.
+
+Here are a couple of useful links to learn more about Intel's AI software:
+
+- Intel Neural Compressor [link](https://github.com/intel/neural-compressor)
+
+## Disclaimer
+
+The license on this model does not constitute legal advice. We are not responsible for the actions of third parties who use this model. Please consult an attorney before using this model for commercial purposes.
+
+## Cite
+
+@article{cheng2023optimize, title={Optimize weight rounding via signed gradient descent for the quantization of llms}, author={Cheng, Wenhua and Zhang, Weiwei and Shen, Haihao and Cai, Yiyang and He, Xin and Lv, Kaokao and Liu, Yi}, journal={arXiv preprint arXiv:2309.05516}, year={2023} }
+
+[arxiv](https://arxiv.org/abs/2309.05516) [github](https://github.com/intel/auto-round)