Update Aroow-Rust-Coder-9B model card

README.md

@@ -1,5 +1,5 @@
 ---
-library_name: transformers
+library_name: peft
 license: apache-2.0
 license_link: https://www.apache.org/licenses/LICENSE-2.0
 pipeline_tag: text-generation
@@ -12,38 +12,267 @@ tags:
 - code
 - code-generation
 - code-completion
+- fill-in-the-middle
 - qwen
 - qwen3.5
-- merged
+- lora
 - bf16
 - convence
 ---
 
-# Aroow-Rust-Coder-9B
+<div align="center">
+  <img src="assets/aroow-rust-coder-9b-banner.png" alt="Aroow-Rust-Coder-9B banner">
+</div>
 
-Aroow-Rust-Coder-9B is a Rust-focused code model by Convence, merged from a PEFT adapter into `Qwen/Qwen3.5-9B`.
+<p align="center">
+    <a href="https://huggingface.co/Convence/Aroow-Rust-Coder-9B" target="_blank">Model Repository</a>
+    |
+    <a href="https://huggingface.co/Qwen/Qwen3.5-9B" target="_blank">Base Model</a>
+    |
+    <a href="https://www.rust-lang.org/" target="_blank">Rust</a>
+    <br>
+    <b>License</b>: <a href="https://www.apache.org/licenses/LICENSE-2.0" target="_blank">Apache 2.0</a>
+    |
+    <b>Author</b>: Convence
+</p>
 
-This repository contains the full merged model weights. It does not require loading a separate LoRA adapter.
+# **Aroow-Rust-Coder-9B**
 
-## Use
+**Aroow-Rust-Coder-9B** is a Rust-focused coding model by **Convence**, built as an adapter for **`Qwen/Qwen3.5-9B`**. It is designed for Rust code generation, code completion, source understanding, fill-in-the-middle editing, unit-test drafting, and practical programming assistance.
+
+The model is intended for developers who want a Rust-specialized assistant that can work with function signatures, module snippets, tests, compiler errors, and implementation requirements. It should be used as part of a normal Rust development workflow with compiler checks, tests, formatting, and review.
+
+## **Model Summary**
+
+| Property | Value |
+| :---- | :---- |
+| **Model Name** | Aroow-Rust-Coder-9B |
+| **Base Model** | `Qwen/Qwen3.5-9B` |
+| **Primary Task** | Rust code generation and completion |
+| **Output Focus** | Rust source code, tests, explanations, refactors |
+| **License** | Apache 2.0 |
+
+## **Intended Use**
+
+Aroow-Rust-Coder-9B is intended for Rust programming assistance in editor, notebook, local inference, and agent-style coding workflows.
+
+Suitable use cases include:
+
+* generating Rust functions from requirements
+* completing partial Rust files
+* writing unit tests
+* explaining Rust code
+* rewriting snippets into more idiomatic Rust
+* assisting with ownership, borrowing, and trait-related issues
+* creating examples for APIs, structs, enums, traits, and modules
+* filling missing code between existing prefix and suffix context
+
+The model is most useful when prompts include concrete constraints, function signatures, examples, or expected behavior.
+
+## **Core Capabilities**
+
+* **Rust Code Generation** - Produces functions, structs, enums, traits, impl blocks, modules, and tests.
+* **Code Completion** - Continues partial Rust code with awareness of surrounding context.
+* **Fill-in-the-Middle Editing** - Completes missing code between prefix and suffix blocks.
+* **Unit-Test Drafting** - Generates `#[test]` functions and `#[cfg(test)]` modules.
+* **Code Explanation** - Explains Rust snippets, control flow, type behavior, and common compiler issues.
+* **Refactoring Assistance** - Suggests cleaner structure, safer patterns, and more idiomatic Rust.
+* **Error-Handling Patterns** - Supports `Result`, `Option`, `?`, pattern matching, and recoverable error flow.
+* **Standard Library Usage** - Works with common collections, iterators, slices, strings, traits, and modules.
+
+## **Getting Started**
+
+Install the required packages:
+
+```bash
+pip install -U transformers peft torch accelerate
+```
+
+Load the base model and adapter:
 
 ```python
 import torch
+from peft import PeftModel
 from transformers import AutoModelForImageTextToText, AutoProcessor
 
-model_id = "Convence/Aroow-Rust-Coder-9B-Merged"
+BASE_MODEL = "Qwen/Qwen3.5-9B"
+ADAPTER_ID = "Convence/Aroow-Rust-Coder-9B"
 
-processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
+processor = AutoProcessor.from_pretrained(BASE_MODEL, trust_remote_code=True)
 tokenizer = processor.tokenizer
+
 model = AutoModelForImageTextToText.from_pretrained(
-    model_id,
+    BASE_MODEL,
     torch_dtype=torch.bfloat16,
     device_map="auto",
     trust_remote_code=True,
 )
+
+model = PeftModel.from_pretrained(model, ADAPTER_ID)
+model.eval()
 ```
 
-## Intended Use
+Generate a Rust answer:
+
+```python
+messages = [
+    {
+        "role": "system",
+        "content": [
+            {
+                "type": "text",
+                "text": "You are Aroow-Rust-Coder-9B, a Rust-focused coding assistant made by Convence. Write clear, safe, idiomatic Rust.",
+            }
+        ],
+    },
+    {
+        "role": "user",
+        "content": [
+            {
+                "type": "text",
+                "text": "Write a Rust function that returns the first duplicate integer in a slice, or None if there is no duplicate. Include unit tests.",
+            }
+        ],
+    },
+]
+
+prompt = processor.apply_chat_template(
+    messages,
+    tokenize=False,
+    add_generation_prompt=True,
+)
+
+inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+input_len = inputs["input_ids"].shape[-1]
+
+outputs = model.generate(
+    **inputs,
+    max_new_tokens=512,
+    do_sample=True,
+    temperature=0.2,
+    top_p=0.95,
+)
 
-The model is intended for Rust code generation, completion, explanation, refactoring, and unit-test drafting.
-Generated code should be validated with `cargo check`, `cargo test`, `cargo fmt`, and `cargo clippy`.
+response = tokenizer.decode(outputs[0][input_len:], skip_special_tokens=True)
+print(response)
+```
+
+## **Prompt Examples**
+
+### Function Implementation
+
+```text
+Write a Rust function:
+
+fn normalize_counts(values: &[u32]) -> Vec<f64>
+
+Requirements:
+* return an empty vector for empty input
+* divide each value by the total sum
+* avoid division by zero
+* include unit tests
+```
+
+### Compiler Error Help
+
+````text
+This Rust code does not compile. Explain the issue and rewrite it idiomatically:
+
+```rust
+fn main() {
+    let values = vec![String::from("alpha"), String::from("beta")];
+    let first = values[0];
+    println!("{:?}", values);
+    println!("{}", first);
+}
+```
+````
+
+### Fill-in-the-Middle Completion
+
+````text
+Fill in the missing Rust code between this prefix and suffix. Return only the missing code.
+
+Prefix:
+```rust
+impl Cache {
+    pub fn get_or_insert_with<F>(&mut self, key: String, f: F) -> &Value
+    where
+        F: FnOnce() -> Value,
+    {
+```
+
+Suffix:
+```rust
+    }
+}
+```
+````
+
+## **Recommended Usage**
+
+For best results:
+
+* provide exact function signatures when possible
+* include edge cases and expected behavior
+* state whether external crates are allowed
+* ask for tests when correctness matters
+* run generated code through `cargo check`
+* run tests with `cargo test`
+* format generated code with `cargo fmt`
+* inspect suggestions before applying them to production code
+
+For deterministic code generation, use a low temperature such as `0.1` to `0.3`. For brainstorming alternative designs, use a higher temperature with careful review.
+
+## **Validation Workflow**
+
+Generated code should be treated as a draft. A recommended Rust validation workflow is:
+
+```bash
+cargo fmt
+cargo check
+cargo test
+cargo clippy
+```
+
+For security-sensitive code, add manual review, dependency review, fuzzing, property tests, and threat modeling where appropriate.
+
+## **Limitations**
+
+Aroow-Rust-Coder-9B may:
+
+* produce code that does not compile
+* comit imports, feature flags, or crate dependencies
+* misunderstand complex lifetimes or trait bounds
+* generate tests that do not cover important edge cases
+* hallucinate APIs or crate behavior
+* produce code that appears correct but fails under real inputs
+* give incomplete explanations of compiler errors
+
+The model should not be used as the sole authority for security-critical, safety-critical, medical, legal, financial, cryptographic, or infrastructure-critical code.
+
+## **Safety**
+
+Developers should avoid sending secrets, credentials, private keys, unreleased proprietary source code, personal data, or regulated information to public inference endpoints.
+
+Generated code should be reviewed before use. Pay special attention to:
+
+* `unsafe` blocks
+* FFI
+* raw pointers
+* authentication logic
+* cryptography
+* file-system access
+* network-facing code
+* dependency and supply-chain risk
+
+## **Citation**
+
+```bibtex
+@misc{convence2026aroowrustcoder9b,
+  title={Aroow-Rust-Coder-9B},
+  author={Convence},
+  year={2026},
+  url={https://huggingface.co/Convence/Aroow-Rust-Coder-9B}
+}
+```