Update README.md

README.md

@@ -6,33 +6,124 @@ tags:
 - generated_from_trainer
 - trl
 - sft
-licence: license
+- function-calling
+- thinking-layer
+license: mit
 ---
 
 # Model Card for gemma-2-2B-it-thinking-function_calling-V0
 
-This model is a fine-tuned version of [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it).
-It has been trained using [TRL](https://github.com/huggingface/trl).
+This model is a fine-tuned version of [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it), specifically trained for function calling with an added "Thinking Layer". The model was trained using [TRL](https://github.com/huggingface/trl) and incorporates an explicit thinking process before making function calls.
 
-## Quick start
+## 🎯 Key Features
+
+- **Function Calling**: Generation of structured function calls
+- **Thinking Layer**: Explicit reasoning process before execution
+- **Supported Functions**:
+  - `convert_currency`: Currency conversion
+  - `calculate_distance`: Distance calculation between locations
+
+## 🚀 Quick Start
+
+### Function Calling Example
 
 ```python
-from transformers import pipeline
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+# Load model and tokenizer
+model_name = "Sellid/gemma-2-2B-it-thinking-function_calling-V0"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(model_name)
 
-question = "If you had a time machine, but could only go to the past or the future once and never return, which would you choose and why?"
-generator = pipeline("text-generation", model="Sellid/gemma-2-2B-it-thinking-function_calling-V0", device="cuda")
-output = generator([{"role": "user", "content": question}], max_new_tokens=128, return_full_text=False)[0]
-print(output["generated_text"])
+# Example for currency conversion
+prompt = """<bos><start_of_turn>human
+You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags.
+Here are the available tools:<tools>[{
+    "type": "function",
+    "function": {
+        "name": "convert_currency",
+        "description": "Convert from one currency to another",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "amount": {"type": "number", "description": "The amount to convert"},
+                "from_currency": {"type": "string", "description": "The currency to convert from"},
+                "to_currency": {"type": "string", "description": "The currency to convert to"}
+            },
+            "required": ["amount", "from_currency", "to_currency"]
+        }
+    }
+}]</tools>
+
+Hi, I need to convert 500 USD to Euros. Can you help me with that?<end_of_turn><eos>
+<start_of_turn>model"""
+
+# Generate response
+inputs = tokenizer(prompt, return_tensors="pt")
+outputs = model.generate(**inputs, max_new_tokens=200)
+print(tokenizer.decode(outputs[0]))
 ```
 
-## Training procedure
+## 🤖 Model Architecture
+
+The model uses a special prompt structure with three main components:
 
- 
+1. **Tools Definition**:
+```xml
+<tools>
+[Function signatures in JSON format]
+</tools>
+```
+
+2. **Thinking Layer**:
+```xml
+<think>
+[Explicit thinking process of the model]
+</think>
+```
+
+3. **Function Call**:
+```xml
+<tool_call>
+{
+    "name": "function_name",
+    "arguments": {
+        "param1": "value1",
+        ...
+    }
+}
+</tool_call>
+```
 
+### Thinking Layer Process
 
-This model was trained with SFT.
+The Thinking Layer executes the following steps:
+1. **Analysis** of user request
+2. **Selection** of appropriate function
+3. **Validation** of parameters
+4. **Generation** of function call
 
-### Framework versions
+## 📊 Performance & Limitations
+
+- **Memory Requirements**: ~4GB RAM
+- **Inference Time**: ~1-2 seconds/request
+- **Supported Platforms**:
+  - CPU
+  - NVIDIA GPUs (CUDA)
+  - Apple Silicon (MPS)
+
+### Limitations
+
+- Limited to pre-trained functions
+- No function call chaining
+- No dynamic function extension
+
+## 🔧 Training Details
+
+The model was trained using SFT (Supervised Fine-Tuning):
+
+### Framework Versions
 
 - TRL: 0.15.1
 - Transformers: 4.49.0
@@ -40,19 +131,29 @@ This model was trained with SFT.
 - Datasets: 3.3.2
 - Tokenizers: 0.21.0
 
-## Citations
+## 📚 Citations
 
+If you use this model, please cite TRL:
 
-
-Cite TRL as:
-    
 ```bibtex
 @misc{vonwerra2022trl,
-	title        = {{TRL: Transformer Reinforcement Learning}},
-	author       = {Leandro von Werra and Younes Belkada and Lewis Tunstall and Edward Beeching and Tristan Thrush and Nathan Lambert and Shengyi Huang and Kashif Rasul and Quentin Gallouédec},
-	year         = 2020,
-	journal      = {GitHub repository},
-	publisher    = {GitHub},
-	howpublished = {\url{https://github.com/huggingface/trl}}
+    title        = {{TRL: Transformer Reinforcement Learning}},
+    author       = {Leandro von Werra and Younes Belkada and Lewis Tunstall and Edward Beeching and Tristan Thrush and Nathan Lambert and Shengyi Huang and Kashif Rasul and Quentin Gallouédec},
+    year         = 2020,
+    journal      = {GitHub repository},
+    publisher    = {GitHub},
+    howpublished = {\url{https://github.com/huggingface/trl}}
+}
+```
+
+And this model:
+
+```bibtex
+@misc{gemma-function-calling-thinking,
+    title        = {Gemma Function-Calling with Thinking Layer},
+    author       = {Sellid},
+    year         = 2024,
+    publisher    = {Hugging Face Model Hub},
+    howpublished = {\url{https://huggingface.co/Sellid/gemma-2-2B-it-thinking-function_calling-V0}}
 }
 ```