Upload README.md with huggingface_hub

README.md

@@ -0,0 +1,125 @@
+---
+license: other
+language:
+- en
+pipeline_tag: text-generation
+inference: false
+tags:
+- transformers
+- gguf
+- imatrix
+- Codestral-22B-v0.1
+---
+Quantizations of https://huggingface.co/mistralai/Codestral-22B-v0.1
+
+
+# From original readme
+
+## Installation
+
+It is recommended to use `mistralai/Codestral-22B-v0.1` with [mistral-inference](https://github.com/mistralai/mistral-inference).
+
+```
+pip install mistral_inference
+```
+
+## Download
+
+```py
+from huggingface_hub import snapshot_download
+from pathlib import Path
+
+mistral_models_path = Path.home().joinpath('mistral_models', 'Codestral-22B-v0.1')
+mistral_models_path.mkdir(parents=True, exist_ok=True)
+
+snapshot_download(repo_id="mistralai/Codestral-22B-v0.1", allow_patterns=["params.json", "consolidated.safetensors", "tokenizer.model.v3"], local_dir=mistral_models_path)
+```
+
+### Chat
+
+After installing `mistral_inference`, a `mistral-chat` CLI command should be available in your environment.
+
+```
+mistral-chat $HOME/mistral_models/Codestral-22B-v0.1 --instruct --max_tokens 256
+```
+
+Will generate an answer to "Write me a function that computes fibonacci in Rust" and should give something along the following lines:
+
+```
+Sure, here's a simple implementation of a function that computes the Fibonacci sequence in Rust. This function takes an integer `n` as an argument and returns the `n`th Fibonacci number.
+
+fn fibonacci(n: u32) -> u32 {
+    match n {
+        0 => 0,
+        1 => 1,
+        _ => fibonacci(n - 1) + fibonacci(n - 2),
+    }
+}
+
+fn main() {
+    let n = 10;
+    println!("The {}th Fibonacci number is: {}", n, fibonacci(n));
+}
+
+This function uses recursion to calculate the Fibonacci number. However, it's not the most efficient solution because it performs a lot of redundant calculations. A more efficient solution would use a loop to iteratively calculate the Fibonacci numbers.
+```
+
+
+### Fill-in-the-middle (FIM)
+
+After installing `mistral_inference` and running `pip install --upgrade mistral_common` to make sure to have mistral_common>=1.2 installed:
+
+```py
+from mistral_inference.model import Transformer
+from mistral_inference.generate import generate
+from mistral_common.tokens.tokenizers.mistral import MistralTokenizer
+from mistral_common.tokens.instruct.request import FIMRequest
+
+tokenizer = MistralTokenizer.v3()
+model = Transformer.from_folder("~/codestral-22B-240529")
+
+prefix = """def add("""
+suffix = """    return sum"""
+
+request = FIMRequest(prompt=prefix, suffix=suffix)
+
+tokens = tokenizer.encode_fim(request).tokens
+
+out_tokens, _ = generate([tokens], model, max_tokens=256, temperature=0.0, eos_id=tokenizer.instruct_tokenizer.tokenizer.eos_id)
+result = tokenizer.decode(out_tokens[0])
+
+middle = result.split(suffix)[0].strip()
+print(middle)
+```
+
+Should give something along the following lines:
+
+```
+num1, num2):
+
+    # Add two numbers
+    sum = num1 + num2
+
+    # return the sum
+```
+
+## Usage with transformers library
+
+This model is also compatible with `transformers` library, first run `pip install -U transformers` then use the snippet below to quickly get started:
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_id = "mistralai/Codestral-22B-v0.1"
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+model = AutoModelForCausalLM.from_pretrained(model_id)
+
+text = "Hello my name is"
+inputs = tokenizer(text, return_tensors="pt")
+
+outputs = model.generate(**inputs, max_new_tokens=20)
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+```
+
+By default, transformers will load the model in full precision. Therefore you might be interested to further reduce down the memory requirements to run the model through the optimizations we offer in HF ecosystem.