---
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)