North Air 1 API — Instance 2 (load-balanced replica)

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+ENV PYTHONUNBUFFERED=1 \
+    PORT=7860
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+COPY . /app
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,11 @@
 ---
-title: North Air Api 2
-emoji: 📚
-colorFrom: green
+title: North Air API 2
+emoji: 🌬️
+colorFrom: blue
 colorTo: green
 sdk: docker
-pinned: false
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# North Air 1 API — Instance 2
+Load-balanced replica.

app.py

@@ -0,0 +1,326 @@
+import os
+import re
+import time
+import json
+from typing import List, Optional
+from threading import Thread
+
+import torch
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from transformers import AutoTokenizer, TextIteratorStreamer
+
+MODEL_DIR = os.getenv("MODEL_DIR", "./final_model")
+MAX_NEW_TOKENS = int(os.getenv("MAX_NEW_TOKENS", "512"))
+TEMPERATURE = float(os.getenv("TEMPERATURE", "0.6"))
+TOP_P = float(os.getenv("TOP_P", "0.85"))
+
+SYSTEM_PROMPT = """You are North Air 1, built by North Air. 0.6B params, a custom model designed for helpful and concise responses.
+Be direct, helpful, concise. Use markdown. Write clean code. Never fabricate facts.
+If asked who you are: "I'm North Air 1, built by North Air." You are NOT ChatGPT/GPT-4/Claude/etc."""
+
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+
+class ChatRequest(BaseModel):
+    messages: List[Message]
+    model: Optional[str] = "north-air-1"
+    max_new_tokens: Optional[int] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    system_prompt: Optional[str] = None
+    stream: Optional[bool] = False
+    enable_thinking: Optional[bool] = False
+
+
+app = FastAPI(title="North Air 1 API", version="4.0.0")
+
+# ─── Model Loading: try ONNX first (fast), fallback to PyTorch ───
+ONNX_SESSION = None
+MODEL = None
+TOKENIZER = None
+LOAD_ERROR = None
+INFERENCE_MODE = "pytorch"  # or "onnx"
+
+
+def _try_load_onnx():
+    """Try to load ONNX Runtime quantized model for 2-4x faster CPU inference."""
+    global ONNX_SESSION, INFERENCE_MODE
+    onnx_path = os.path.join(MODEL_DIR, "model_quantized.onnx")
+    if not os.path.exists(onnx_path):
+        onnx_path = os.path.join(MODEL_DIR, "model.onnx")
+    if not os.path.exists(onnx_path):
+        return False
+
+    try:
+        import onnxruntime as ort
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        sess_options.intra_op_num_threads = 4
+        sess_options.inter_op_num_threads = 2
+        sess_options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
+
+        ONNX_SESSION = ort.InferenceSession(
+            onnx_path, sess_options,
+            providers=["CPUExecutionProvider"],
+        )
+        INFERENCE_MODE = "onnx"
+        print(f"ONNX Runtime loaded: {onnx_path}")
+        return True
+    except Exception as e:
+        print(f"ONNX load failed: {e}")
+        return False
+
+
+def _load_model():
+    """Load model — ONNX quantized if available, else PyTorch."""
+    global MODEL, TOKENIZER, LOAD_ERROR, INFERENCE_MODE
+
+    try:
+        TOKENIZER = AutoTokenizer.from_pretrained(MODEL_DIR, use_fast=True, trust_remote_code=True)
+        if TOKENIZER.pad_token is None:
+            TOKENIZER.pad_token = TOKENIZER.eos_token
+    except Exception as e:
+        LOAD_ERROR = f"Tokenizer load failed: {e}"
+        return
+
+    # Try ONNX first
+    if _try_load_onnx():
+        print(f"Using ONNX Runtime ({INFERENCE_MODE})")
+        return
+
+    # Fallback: PyTorch with optimizations
+    try:
+        from transformers import AutoModelForCausalLM
+        adapter_cfg = os.path.join(MODEL_DIR, "adapter_config.json")
+
+        if os.path.exists(adapter_cfg):
+            from peft import AutoPeftModelForCausalLM
+            MODEL = AutoPeftModelForCausalLM.from_pretrained(
+                MODEL_DIR, torch_dtype=torch.float32, device_map={"": "cpu"},
+            )
+        else:
+            MODEL = AutoModelForCausalLM.from_pretrained(
+                MODEL_DIR, torch_dtype=torch.float32, device_map={"": "cpu"},
+                trust_remote_code=True,
+            )
+
+        MODEL.eval()
+
+        # Dynamic INT8 quantization — only for non-PEFT models
+        # PEFT/LoRA models break with quantize_dynamic due to adapter wrapping
+        if not os.path.exists(adapter_cfg):
+            try:
+                MODEL = torch.quantization.quantize_dynamic(
+                    MODEL, {torch.nn.Linear}, dtype=torch.qint8,
+                )
+                INFERENCE_MODE = "pytorch-int8"
+                print("PyTorch dynamic INT8 quantization applied")
+            except Exception as e:
+                INFERENCE_MODE = "pytorch"
+                print(f"Quantization skipped: {e}")
+        else:
+            INFERENCE_MODE = "pytorch"
+            print("PEFT model detected — skipping quantization (incompatible)")
+
+        print(f"Model loaded: {INFERENCE_MODE}")
+
+    except Exception as e:
+        LOAD_ERROR = str(e)
+
+
+_load_model()
+
+
+@app.get("/health")
+def health():
+    ok = (MODEL is not None) or (ONNX_SESSION is not None)
+    return {
+        "ok": ok,
+        "model": "north-air-1",
+        "version": "4.0.0",
+        "architecture": "Qwen3-0.6B + LoRA r=64",
+        "inference": INFERENCE_MODE,
+        "features": ["streaming", "thinking", "quantized"],
+        "model_dir": MODEL_DIR,
+        "error": LOAD_ERROR,
+    }
+
+
+def _build_prompt(messages: list, system: str, enable_thinking: bool) -> str:
+    has_system = any(m["role"] == "system" for m in messages)
+    if not has_system:
+        messages = [{"role": "system", "content": system}] + messages
+
+    if hasattr(TOKENIZER, "apply_chat_template"):
+        return TOKENIZER.apply_chat_template(
+            messages, tokenize=False, add_generation_prompt=True,
+            enable_thinking=enable_thinking,
+        )
+    return "\n".join(f"{m['role']}: {m['content']}" for m in messages) + "\nassistant:"
+
+
+def _parse_thinking(text: str) -> tuple:
+    think_match = re.search(r"<think>(.*?)</think>", text, re.DOTALL)
+    if think_match:
+        thinking = think_match.group(1).strip()
+        answer = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
+        return thinking, answer
+    return "", text
+
+
+def _generation_kwargs(input_ids, attention_mask, max_new_tokens, temperature, top_p, **extra):
+    return {
+        "input_ids": input_ids,
+        "attention_mask": attention_mask,
+        "max_new_tokens": max_new_tokens,
+        "temperature": max(temperature, 0.01),
+        "top_p": top_p,
+        "top_k": 40,
+        "do_sample": True,
+        "repetition_penalty": 1.2,
+        "pad_token_id": TOKENIZER.pad_token_id,
+        "eos_token_id": TOKENIZER.eos_token_id,
+        **extra,
+    }
+
+
+def _check_model():
+    if MODEL is None and ONNX_SESSION is None:
+        raise HTTPException(status_code=500, detail=f"Model failed to load: {LOAD_ERROR}")
+    if TOKENIZER is None:
+        raise HTTPException(status_code=500, detail=f"Tokenizer failed to load: {LOAD_ERROR}")
+
+
+def _prepare_request(req: ChatRequest):
+    system = req.system_prompt or SYSTEM_PROMPT
+    messages = [{"role": m.role, "content": m.content} for m in req.messages]
+    enable_thinking = req.enable_thinking if req.enable_thinking is not None else False
+
+    prompt = _build_prompt(messages, system, enable_thinking)
+    batch = TOKENIZER(prompt, return_tensors="pt", add_special_tokens=False)
+
+    max_new_tokens = req.max_new_tokens or MAX_NEW_TOKENS
+    temperature = req.temperature if req.temperature is not None else TEMPERATURE
+    top_p = req.top_p if req.top_p is not None else TOP_P
+
+    return batch, max_new_tokens, temperature, top_p
+
+
+@app.post("/chat")
+def chat(req: ChatRequest):
+    _check_model()
+
+    if not req.messages:
+        raise HTTPException(status_code=400, detail="messages are required")
+
+    if req.stream:
+        return chat_stream(req)
+
+    batch, max_new_tokens, temperature, top_p = _prepare_request(req)
+    input_ids = batch["input_ids"]
+    attention_mask = batch["attention_mask"]
+
+    t0 = time.time()
+
+    with torch.no_grad():
+        out = MODEL.generate(
+            **_generation_kwargs(input_ids, attention_mask, max_new_tokens, temperature, top_p)
+        )
+
+    elapsed = time.time() - t0
+    generated_ids = out[0][input_ids.shape[1]:]
+    completion = TOKENIZER.decode(generated_ids, skip_special_tokens=True).strip()
+    thinking, answer = _parse_thinking(completion)
+
+    return {
+        "output": answer,
+        "thinking": thinking if thinking else None,
+        "model": "north-air-1",
+        "inference": INFERENCE_MODE,
+        "tokens_generated": len(generated_ids),
+        "latency_ms": round(elapsed * 1000),
+    }
+
+
+@app.post("/chat/stream")
+def chat_stream(req: ChatRequest):
+    _check_model()
+
+    if not req.messages:
+        raise HTTPException(status_code=400, detail="messages are required")
+
+    batch, max_new_tokens, temperature, top_p = _prepare_request(req)
+    input_ids = batch["input_ids"]
+    attention_mask = batch["attention_mask"]
+
+    streamer = TextIteratorStreamer(TOKENIZER, skip_prompt=True, skip_special_tokens=True)
+
+    gen_kwargs = _generation_kwargs(
+        input_ids, attention_mask, max_new_tokens, temperature, top_p,
+        streamer=streamer,
+    )
+
+    t0 = time.time()
+    thread = Thread(target=_generate_in_thread, args=(gen_kwargs,))
+    thread.start()
+
+    def event_stream():
+        token_count = 0
+        in_thinking = False
+        buf = ""
+
+        for token_text in streamer:
+            buf += token_text
+            token_count += 1
+
+            if "<think>" in buf and not in_thinking:
+                in_thinking = True
+                yield f"data: {json.dumps({'type': 'thinking_start'})}\n\n"
+                after = buf.split("<think>", 1)[1]
+                buf = after if after else ""
+
+            if "</think>" in buf and in_thinking:
+                before = buf.split("</think>", 1)[0]
+                if before:
+                    yield f"data: {json.dumps({'type': 'thinking', 'text': before})}\n\n"
+                in_thinking = False
+                yield f"data: {json.dumps({'type': 'thinking_end'})}\n\n"
+                after = buf.split("</think>", 1)[1].lstrip()
+                buf = ""
+                if after:
+                    yield f"data: {json.dumps({'type': 'text', 'text': after})}\n\n"
+                continue
+
+            partial_open = "<think"
+            partial_close = "</think"
+            if not in_thinking and buf.endswith(tuple(partial_open[:i] for i in range(1, len(partial_open) + 1))):
+                continue
+            if in_thinking and buf.endswith(tuple(partial_close[:i] for i in range(1, len(partial_close) + 1))):
+                continue
+
+            if buf:
+                evt_type = "thinking" if in_thinking else "text"
+                yield f"data: {json.dumps({'type': evt_type, 'text': buf})}\n\n"
+                buf = ""
+
+        if buf:
+            evt_type = "thinking" if in_thinking else "text"
+            yield f"data: {json.dumps({'type': evt_type, 'text': buf})}\n\n"
+        if in_thinking:
+            yield f"data: {json.dumps({'type': 'thinking_end'})}\n\n"
+
+        thread.join()
+        elapsed = time.time() - t0
+        yield f"data: {json.dumps({'type': 'done', 'tokens_generated': token_count, 'latency_ms': round(elapsed * 1000), 'inference': INFERENCE_MODE})}\n\n"
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+
+def _generate_in_thread(kwargs):
+    with torch.no_grad():
+        MODEL.generate(**kwargs)

final_model/README.md

@@ -0,0 +1,207 @@
+---
+base_model: Qwen/Qwen3-0.6B
+library_name: peft
+pipeline_tag: text-generation
+tags:
+- base_model:adapter:Qwen/Qwen3-0.6B
+- lora
+- transformers
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.18.1

final_model/adapter_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a71d98c372775193e6199d70ffd998eabb5c8afc4d27f416dfd15faa81be0227
+size 1047

final_model/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:764e42d66fb3bbca0fc6856001d844a41003a9fef1dd4d174e65d25507bc7462
+size 161533160

final_model/chat_template.jinja

@@ -0,0 +1,89 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0].role == 'system' %}
+        {{- messages[0].content + '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0].content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" and message.content is string and not(message.content.startswith('<tool_response>') and message.content.endswith('</tool_response>')) %}
+        {%- set ns.multi_step_tool = false %}
+        {%- set ns.last_query_index = index %}
+    {%- endif %}
+{%- endfor %}
+{%- for message in messages %}
+    {%- if message.content is string %}
+        {%- set content = message.content %}
+    {%- else %}
+        {%- set content = '' %}
+    {%- endif %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {%- if loop.last or (not loop.last and reasoning_content) %}
+                {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+            {%- else %}
+                {{- '<|im_start|>' + message.role + '\n' + content }}
+            {%- endif %}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if (loop.first and content) or (not loop.first) %}
+                    {{- '\n' }}
+                {%- endif %}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<tool_call>\n{"name": "' }}
+                {{- tool_call.name }}
+                {{- '", "arguments": ' }}
+                {%- if tool_call.arguments is string %}
+                    {{- tool_call.arguments }}
+                {%- else %}
+                    {{- tool_call.arguments | tojson }}
+                {%- endif %}
+                {{- '}\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.first or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- endif %}
+{%- endif %}

final_model/config-2.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e2352a177becce1e5e426d29523f133a7a6168cd19d2c77cfd8a8dda875a738
+size 1145

final_model/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f34c44eb123a0f78dbc782f08e5543c2073ed4208e5f8ef2f3bf13c19b1d079d
+size 11422748

final_model/tokenizer_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47bfa3e7727312946b29ac10d6dd0672d63cf7815b2a160b9523872040d2e536
+size 665

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+pydantic==2.9.2
+torch>=2.2.0
+transformers>=4.45.0
+peft>=0.12.0
+accelerate>=0.34.2
+sentencepiece>=0.2.0
+safetensors>=0.4.5