Create README.md

README.md

@@ -0,0 +1,282 @@
+---
+base_model: Qwen/Qwen2-7B-Instruct
+library_name: peft
+license: other
+tags:
+- llama-factory
+- lora
+- generated_from_trainer
+model-index:
+- name: train_2024-06-17-19-49-05
+  results: []
+---
+
+<!-- This model card has been generated automatically according to the information the Trainer had access to. You
+should probably proofread and complete it, then remove this comment. -->
+
+# Install some dependency 
+```bash
+pip install peft transformers bitsandbytes
+```
+
+# Inference 
+```python
+import json
+import re
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Literal, Optional, Sequence, Set, Tuple, Union
+
+def calculate_gpa(grades: Sequence[str], hours: Sequence[int]) -> float:
+    grade_to_score = {"A": 4, "B": 3, "C": 2}
+    total_score, total_hour = 0, 0
+    for grade, hour in zip(grades, hours):
+        total_score += grade_to_score[grade] * hour
+        total_hour += hour
+    return round(total_score / total_hour, 2)
+
+tool_map = {"calculate_gpa": calculate_gpa}
+
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextStreamer
+from peft import PeftModel
+
+tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-7B-Instruct")
+model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-7B-Instruct", 
+                                             torch_dtype="auto", device_map="auto", load_in_4bit = True)
+
+model = PeftModel.from_pretrained(model, "svjack/Qwen2-7B_Function_Call_tiny_lora")
+streamer = TextStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+
+SLOTS = Sequence[Union[str, Set[str], Dict[str, str]]]
+
+
+DEFAULT_TOOL_PROMPT = (
+    "You have access to the following tools:\n{tool_text}"
+    "Use the following format if using a tool:\n"
+    "```\n"
+    "Action: tool name (one of [{tool_names}]).\n"
+    "Action Input: the input to the tool, in a JSON format representing the kwargs "
+    """(e.g. ```{{"input": "hello world", "num_beams": 5}}```).\n"""
+    "```\n"
+)
+
+def default_tool_formatter(tools: List[Dict[str, Any]]) -> str:
+    tool_text = ""
+    tool_names = []
+    for tool in tools:
+        param_text = ""
+        for name, param in tool["parameters"]["properties"].items():
+            required = ", required" if name in tool["parameters"].get("required", []) else ""
+            enum = ", should be one of [{}]".format(", ".join(param["enum"])) if param.get("enum", None) else ""
+            items = (
+                ", where each item should be {}".format(param["items"].get("type", "")) if param.get("items") else ""
+            )
+            param_text += "  - {name} ({type}{required}): {desc}{enum}{items}\n".format(
+                name=name,
+                type=param.get("type", ""),
+                required=required,
+                desc=param.get("description", ""),
+                enum=enum,
+                items=items,
+            )
+
+        tool_text += "> Tool Name: {name}\nTool Description: {desc}\nTool Args:\n{args}\n".format(
+            name=tool["name"], desc=tool.get("description", ""), args=param_text
+        )
+        tool_names.append(tool["name"])
+
+    return DEFAULT_TOOL_PROMPT.format(tool_text=tool_text, tool_names=", ".join(tool_names))
+
+def default_tool_extractor(content: str) -> Union[str, List[Tuple[str, str]]]:
+    regex = re.compile(r"Action:\s*([a-zA-Z0-9_]+)\s*Action Input:\s*(.+?)(?=\s*Action:|\s*$)", re.DOTALL)
+    action_match: List[Tuple[str, str]] = re.findall(regex, content)
+    if not action_match:
+        return content
+
+    results = []
+    for match in action_match:
+        tool_name = match[0].strip()
+        tool_input = match[1].strip().strip('"').strip("```")
+        try:
+            arguments = json.loads(tool_input)
+            results.append((tool_name, json.dumps(arguments, ensure_ascii=False)))
+        except json.JSONDecodeError:
+            return content
+
+    return results
+
+#### Function tool defination
+tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "calculate_gpa",
+                "description": "Calculate the Grade Point Average (GPA) based on grades and credit hours",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "grades": {"type": "array", "items": {"type": "string"}, "description": "The grades"},
+                        "hours": {"type": "array", "items": {"type": "integer"}, "description": "The credit hours"},
+                    },
+                    "required": ["grades", "hours"],
+                },
+            },
+        }
+    ]
+
+tools_input = list(map(lambda x: x["function"], tools))
+system_tool_prompt = default_tool_formatter(tools_input)
+#print(system_tool_prompt)
+
+def qwen_hf_predict(messages, qw_model = model,
+    tokenizer = tokenizer, streamer = streamer,
+    do_sample = True,
+    top_p = 0.95,
+    top_k = 40,
+    max_new_tokens = 512,
+    max_input_length = 3500,
+    temperature = 0.9,
+    repetition_penalty = 1.0,
+    device = "cuda"):
+
+    encodeds = tokenizer.apply_chat_template(messages, return_tensors="pt",
+        add_generation_prompt=True
+    )
+    model_inputs = encodeds.to(device)
+
+    generated_ids = qw_model.generate(model_inputs, max_new_tokens=max_new_tokens,
+                                do_sample=do_sample,
+                                  streamer = streamer,
+                                  top_p = top_p,
+                                  top_k = top_k,
+                                  temperature = temperature,
+                                  repetition_penalty = repetition_penalty,
+                                  )
+    out = tokenizer.batch_decode(generated_ids)[0].split("<|im_start|>assistant")[-1].replace("<|im_end|>", "").strip()
+    return out
+
+messages = [
+    {
+        "role" :"system",
+        "content": system_tool_prompt
+    },
+    {"role": "user", "content": "My grades are A, A, B, and C. The credit hours are 3, 4, 3, and 2."}
+]
+
+out = qwen_hf_predict(messages)
+tool_out = default_tool_extractor(out)
+print(tool_out)
+
+name, arguments = tool_out[0][0], json.loads(tool_out[0][1])
+tool_result = tool_map[name](**arguments)
+print(tool_result)
+
+messages.append(
+    {
+        "role" :"assistant",
+        "content": out
+    }
+)
+
+messages.append({"role": "tool", "content": json.dumps({"gpa": tool_result}, ensure_ascii=False)})
+
+final_out = qwen_hf_predict(messages)
+print(final_out)
+```
+
+# Output 
+```
+Action: calculate_gpa
+Action Input: {"grades": ["A", "A", "B", "C"], "hours": [3, 4, 3, 2]}
+[('calculate_gpa', '{"grades": ["A", "A", "B", "C"], "hours": [3, 4, 3, 2]}')]
+3.42
+Based on the grades and credit hours you provided, your Grade Point Average (GPA) is 3.42.
+```
+
+# Inference 
+```python
+messages = [
+    {
+        "role" :"system",
+        "content": system_tool_prompt
+    },
+    {"role": "user", "content": "我的成绩分别是A,A,B,C学分分别是3, 4, 3,和2"}
+]
+
+out = qwen_hf_predict(messages)
+tool_out = default_tool_extractor(out)
+print(tool_out)
+
+name, arguments = tool_out[0][0], json.loads(tool_out[0][1])
+tool_result = tool_map[name](**arguments)
+print(tool_result)
+
+messages.append(
+    {
+        "role" :"assistant",
+        "content": out
+    }
+)
+
+messages.append({"role": "tool", "content": json.dumps({"gpa": tool_result}, ensure_ascii=False)})
+
+final_out = qwen_hf_predict(messages)
+print(final_out)
+```
+
+# Output 
+```
+Action: calculate_gpa
+Action Input: {"grades": ["A", "A", "B", "C"], "hours": [3, 4, 3, 2]}
+[('calculate_gpa', '{"grades": ["A", "A", "B", "C"], "hours": [3, 4, 3, 2]}')]
+3.42
+您的绩点（GPA）是3.42。
+```
+
+
+# train_2024-06-17-19-49-05
+
+This model is a fine-tuned version of [Qwen/Qwen2-7B-Instruct](https://huggingface.co/Qwen/Qwen2-7B-Instruct) on the glaive_toolcall_zh and the glaive_toolcall_en datasets.
+
+## Model description
+
+More information needed
+
+## Intended uses & limitations
+
+More information needed
+
+## Training and evaluation data
+
+More information needed
+
+## Training procedure
+
+### Training hyperparameters
+
+The following hyperparameters were used during training:
+- learning_rate: 5e-05
+- train_batch_size: 1
+- eval_batch_size: 8
+- seed: 42
+- distributed_type: multi-GPU
+- num_devices: 2
+- gradient_accumulation_steps: 8
+- total_train_batch_size: 16
+- total_eval_batch_size: 16
+- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
+- lr_scheduler_type: cosine
+- num_epochs: 3.0
+- mixed_precision_training: Native AMP
+
+### Training results
+
+
+
+### Framework versions
+
+- PEFT 0.11.1
+- Transformers 4.41.2
+- Pytorch 2.3.1+cu121
+- Datasets 2.20.0
+- Tokenizers 0.19.1