Create README.md

README.md

@@ -0,0 +1,299 @@
+---
+base_model:
+- openai/gpt-oss-20b
+---
+
+## Model Details
+
+This model is a gguf q4ks format of  [openai/gpt-oss-120b](https://huggingface.co/openai/gpt-oss-120b)  generated by [intel/auto-round](https://github.com/intel/auto-round) algorithm. 
+
+Please follow the license of the original model.
+
+## How To Use
+
+Llamacpp inference
+
+~~~bash
+llama-cli -hf Intel/gpt-oss-120b-gguf-q4ks-AutoRound
+~~~
+
+~~~bash
+> Write a quick sort algorithm.
+<|channel|>analysis<|message|>The user: "Write a quick sort algorithm." Likely they want code in some language. I should provide a quicksort implementation, possibly multiple languages, explain. I can give Python example. Also discuss partition scheme. Provide code.
+
+I'll respond with an example in Python, plus explanation. Also could include C++ version. Provide generic.<|start|>assistant<|channel|>final<|message|>Below is a complete, ready‑to‑run implementation of the Quick‑Sort algorithm together with a short explanation of how it works.
+You’ll find versions in **Python**, **C++**, and **JavaScript** so you can pick the one that best fits your project.
+
+---
+
+## 1. Quick‑Sort Overview
+
+Quick‑Sort is a divide‑and‑conquer sorting algorithm that works in three steps:
+
+1. **Choose a pivot** element from the array (any element works, but a good choice reduces the chance of worst‑case O(n²) behavior).
+2. **Partition** the array into two sub‑arrays:
+   * Elements **≤ pivot** go to the left side.
+   * Elements **> pivot** go to the right side.
+3. **Recursively** apply Quick‑Sort to the left and right sub‑arrays.
+
+The algorithm runs in **average O(n log n)** time and **O(log n)** extra space (the recursion stack). The in‑place version shown below uses the **Lomuto partition scheme**, which is easy to understand and implement.
+
+---
+
+## 2. Python Implementation (In‑Place)
+
+```python
+def quicksort(arr, low=0, high=None):
+    """
+    In‑place quicksort.
+    Parameters
+    ----------
+    arr : list
+        The list to be sorted.
+    low : int, optional
+        Starting index of the sub‑list to sort (default 0).
+    high : int, optional
+        End index (inclusive) of the sub‑list to sort.
+        If None, the whole list is sorted.
+    """
+    if high is None:
+        high = len(arr) - 1
+
+    # Base case: a segment of length 0 or 1 is already sorted
+    if low < high:
+        # Partition the segment and get the pivot's final index
+        p = _partition(arr, low, high)
+
+        # Recursively sort the two halves
+        quicksort(arr, low, p - 1)
+        quicksort(arr, p + 1, high)
+
+
+def _partition(arr, low, high):
+    """
+    Lomuto partition scheme.
+    Returns the final index of the pivot.
+    """
+    pivot = arr[high]                # Choose the rightmost element as pivot
+    i = low - 1                      # Index of the smaller element
+
+    for j in range(low, high):
+        if arr[j] <= pivot:          # If current element <= pivot
+            i += 1
+            arr[i], arr[j] = arr[j], arr[i]   # Swap it to the front
+
+    # Place the pivot after the last smaller element
+    arr[i + 1], arr[high] = arr[high], arr[i + 1]
+    return i + 1                     # Return the pivot's final position
+
+
+# -----------------------------
+# Example usage
+if __name__ == "__main__":
+    data = [33, 10, 55, 71, 29, 3, 90, 42]
+    print("Before:", data)
+    quicksort(data)
+    print("After :", data)
+```
+
+**What the code does**
+
+* `quicksort` is the public entry point. It accepts a mutable list and sorts it in place.
+* `_partition` rearranges the elements around a pivot (chosen as the last element). After partitioning, every element left of the returned index is ≤ pivot, and everything right is > pivot.
+* The recursion depth is bounded by `O(log n)` on average, but in the worst case (already sorted input with the naive pivot choice) it can degrade to `O(n)`. To avoid that, you can:
+  * Randomly shuffle the array before sorting, **or**
+  * Use a **median‑of‑three** or **random pivot** selection inside `_partition`.
+
+---
+
+## 3. C++ Implementation (In‑Place)
+
+```cpp
+#include <iostream>
+#include <vector>
+#include <cstdlib>   // std::rand, std::srand
+#include <ctime>     // std::time
+
+// Lomuto partition
+int partition(std::vector<int>& a, int low, int high) {
+    int pivot = a[high];                 // Choose rightmost element as pivot
+    int i = low - 1;                     // Index of smaller element
+
+    for (int j = low; j < high; ++j) {
+        if (a[j] <= pivot) {
+            ++i;
+            std::swap(a[i], a[j]);
+        }
+    }
+    std::swap(a[i + 1], a[high]);        // Place pivot in its final spot
+    return i + 1;                        // Return pivot index
+}
+
+// Recursive quicksort
+void quicksort(std::vector<int>& a, int low, int high) {
+    if (low < high) {
+        int p = partition(a, low, high);
+        quicksort(a, low, p - 1);
+        quicksort(a, p + 1, high);
+    }
+}
+
+// Helper that sorts the whole vector
+void quicksort(std::vector<int>& a) {
+    quicksort(a, 0, static_cast<int>(a.size()) - 1);
+}
+
+// -------------------------------------------------
+int main() {
+    std::srand(static_cast<unsigned>(std::time(nullptr))); // optional random seed
+
+    std::vector<int> data = {33, 10, 55, 71, 29, 3, 90, 42};
+
+    std::cout << "Before: ";
+    for (int x : data) std::cout << x << ' ';
+    std::cout << '\n';
+
+    quicksort(data);
+
+    std::cout << "After : ";
+    for (int x : data) std::cout << x << ' ';
+    std::cout << '\n';
+}
+```
+
+**Notes**
+
+* The algorithm is identical to the Python version, just expressed with C++ syntax.
+* `std::swap` does the element exchange.
+* If you want a *random pivot* to improve average performance, replace the line `int pivot = a[high];` with:
+
+```cpp
+int randIdx = low + std::rand() % (high - low + 1);
+std::swap(a[randIdx], a[high]);   // move random element to the end
+int pivot = a[high];
+```
+
+---
+
+## 4. JavaScript Implementation (In‑Place)
+
+```js
+/**
+ * In‑place quicksort for an array of numbers.
+ * @param {Array<number>} arr - The array to sort.
+ * @param {number} low - Starting index (default 0).
+ * @param {number} high - Ending index (default arr.length‑1).
+ */
+function quicksort(arr, low = 0, high = arr.length - 1) {
+    if (low < high) {
+        const p = partition(arr, low, high);
+        quicksort(arr, low, p - 1);
+        quicksort(arr, p + 1, high);
+    }
+}
+
+/**
+ * Lomuto partition scheme.
+ * @returns {number} Final index of the pivot.
+ */
+function partition(arr, low, high) {
+    const pivot = arr[high];   // rightmost element as pivot
+    let i = low - 1;
+
+    for (let j = low; j < high; ++j) {
+        if (arr[j] <= pivot) {
+            ++i;
+            [arr[i], arr[j]] = [arr[j], arr[i]]; // swap via destructuring
+        }
+    }
+    // place pivot after the last smaller element
+    [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
+    return i + 1;
+}
+
+// ---------------------------
+// Example usage
+const data = [33, 10, 55, 71, 29, 3, 90, 42];
+console.log('Before:', data);
+quicksort(data);
+console.log('After :', data);
+```
+
+---
+
+## 5. Quick‑Sort Variants & Tips
+
+| Variant | When to use it | Key idea |
+|---------|----------------|----------|
+| **Random pivot** | When you can’t guarantee input order | Randomly pick a pivot to make worst‑case probability negligible |
+| **Median‑of‑three** | Small overhead, good practical performance | Choose pivot as median of first, middle, last elements |
+| **Three‑way (Dutch‑national‑flag) partition** | When the array contains many duplicate keys | Split into `< pivot`, `= pivot`, `> pivot` to avoid O(n²) on many equal elements |
+| **Iterative Quick‑Sort** | When recursion depth may overflow (very large arrays) | Use an explicit stack (or tail‑call optimisation) instead of recursion |
+
+---
+
+## 6. Complexity Recap
+
+| Metric | Average case | Worst case | Space (auxiliary) |
+|--------|--------------|-----------|-------------------|
+| Time   | **O(n log n)** | **O(n²)** (e.g., already sorted with naive pivot) | **O(log n)** recursion depth (in‑place) |
+| Stability | **No** (elements with equal keys may be reordered) | – | – |
+
+If you need a **stable** sort, consider Merge‑Sort or TimSort (the algorithm used by Python’s built‑in `list.sort()`).
+
+---
+
+### TL;DR – Quick‑Sort in a nutshell
+
+```python
+def quicksort(arr):
+    if len(arr) <= 1:
+        return arr
+    pivot = arr[-1]
+    left  = [x for x in arr[:-1] if x <= pivot]
+    right = [x for x in arr[:-1] if x >  pivot]
+    return quicksort(left) + [pivot] + quicksort(right)
+```
+
+The one‑liner above is a **functional** (non‑in‑place) version that is easy to understand but uses O(n) extra memory for each recursive call.
+
+Pick the version that fits your constraints, and you’ll have a fast, reliable sorting routine ready to go!
+
+~~~
+
+### Generate the model
+
+#### Requirement
+pip install git+https://github.com/intel/auto-round.git@hengguo/gguf_update_0806
+
+Here is the sample command to reproduce the model
+
+```bash
+auto_round --format gguf:q4_k_s --iters 0 --nsamples 512 --model openai/gpt-oss-120b --output_dir tmp_autoround
+```
+
+
+
+## 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)