Upload README.md

README.md

@@ -0,0 +1,221 @@
+---
+license: apache-2.0
+language:
+- en
+metrics:
+- accuracy
+pipeline_tag: text-generation
+
+model-index:
+  - name: Qwen2-Simple-Arguments
+    results:
+      - task:
+          type: text-generation
+        dataset:
+          name: Argument-parsing
+          type: Argument-parsing
+        metrics:
+          - name: Accuracy
+            type: Accuracy
+            value: 100
+---
+# Qwen2 Simple Arguments
+![image](assets/qwen_arguments_logo.png)
+[![image](assets/hire_me.png)](https://www.freelancer.com/u/cdesivo92)
+
+This model aims to parse simple english arguments, arguments formed of two premises and a conclusion, including two propositions.
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+- **Developed by:** Cristian Desivo
+- **Model type:** LLM
+- **Language(s) (NLP):** English
+- **License:** Apache-2.0
+- **Finetuned from model:** Qwen2-0.5b
+
+### Model Sources
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** TBD
+- **Demo:** TBD
+
+### Quantization
+
+- **Q4_K_M.gguf** https://huggingface.co/cris177/Qwen2-Simple-Arguments/resolve/main/Qwen2_arguments.Q4_K_M.gguf?download=true
+
+## Usage
+
+Below we share some code snippets on how to get quickly started with running the model.
+
+### llama.cpp server [Recommended]
+
+The recommended way of running the model is with a llama.cpp server running the quantized https://huggingface.co/cris177/Qwen2-Simple-Arguments/resolve/main/Qwen2_arguments.Q4_K_M.gguf?download=true
+
+Then you can use the following script to use the server's model for inference:
+
+```python
+import json
+import requests
+
+def llmCompletion(prompt, **args):
+    url = "http://localhost:8080/completions"
+    headers = {
+        "Content-Type": "application/json"
+    }
+    data = {
+        'prompt': prompt
+    }
+    for arg in args:
+        data[arg] = args[arg]
+    response = requests.post(url, headers=headers, json=data)
+    return response.json()
+
+def analyze_argument(argument):
+    instruction = 'Based on the following argument, identify the following elements: premises, conclusion, propositions, type of argument, negation of propositions and validity.'
+    alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
+
+### Instruction:
+{}
+
+### Input:
+{}
+
+### Response:"""
+    prompt = alpaca_prompt.format(instruction, argument)
+    with open("prompt.txt", "w") as f:
+        f.write(prompt) 
+    properties = {
+        "Premise 1": {"type": "string"},
+        "Premise 2": {"type": "string"},
+        "Conclusion": {"type": "string"},
+        "Proposition 1": {"type": "string"},
+        "Proposition 2": {"type": "string"},
+        "Type of argument": {"type": "string"},
+        "Negation of Proposition 1": {"type": "string"},
+        "Negation of Proposition 2": {"type": "string"},
+        "Validity": {"type": "boolean"},
+    }
+    analysis = llmCompletion(prompt,
+        max_tokens=1000,
+        temperature=0,
+        json_schema={
+            "type": "object",
+            "properties": properties,
+            "required": list(properties.keys()),
+            },
+    )
+    return analysis['content']
+
+argument = "If it's wednesday it's cold, and it's cold, therefore it's wednesday."
+output = analyze_argument("If it's wednesday it's cold, and it's cold, therefore it's wednesday.")
+print(output)
+```
+Output:
+```
+{"Premise 1": "If it's wednesday it's cold",
+"Premise 2": "It's cold",
+"Conclusion": "It is Wednesday",
+"Proposition 1": "It is Wednesday",
+"Proposition 2": "It is cold",
+"Type of argument": "affirming the consequent",
+"Negation of Proposition 1": "It is not Wednesday",
+"Negation of Proposition 2": "It is not cold",
+"Validity": true}
+```
+
+### transformers 🤗
+First make sure to pip install -U transformers, then use the code below replacing the `argument` variable for the argument you want to parse:
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model = AutoModelForCausalLM.from_pretrained("cris177/Qwen2-Simple-Arguments", 
+    device_map="auto",)
+tokenizer = AutoTokenizer.from_pretrained("cris177/Qwen2-Simple-Arguments")
+
+argument = "If it's wednesday it's cold, and it's cold, therefore it's wednesday."
+
+instruction = 'Based on the following argument, identify the following elements: premises, conclusion, propositions, type of argument, negation of propositions and validity.'
+alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
+
+### Instruction:
+{}
+
+### Input:
+{}
+
+### Response:"""
+prompt = alpaca_prompt.format(instruction, argument)
+input_ids = tokenizer(prompt, return_tensors="pt").to("cuda")
+
+outputs = model.generate(**input_ids, max_length=1000, num_return_sequences=1)
+print(tokenizer.decode(outputs[0]))
+```
+Output:
+```
+Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
+
+### Instruction:
+Based on the following argument, identify the following elements: premises, conclusion, propositions, type of argument, negation of propositions and validity.
+
+### Input:
+If it's wednesday it's cold, and it's cold, therefore it's wednesday.
+
+### Response: 
+{"Premise 1": "If it's wednesday it's cold",
+"Premise 2": "It's cold",
+"Conclusion": "It is Wednesday",
+"Proposition 1": "It is Wednesday",
+"Proposition 2": "It is cold",
+"Type of argument": "affirming the consequent",
+"Negation of Proposition 1": "It is not Wednesday",
+"Negation of Proposition 2": "It is not cold",
+"Validity": "false"}<|endoftext|>
+```
+
+
+## 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. -->
+
+The model was trained on syntethic data, based on the following types of arguments: 
+- Modus Ponen
+- Modus Tollen
+- Affirming Consequent
+- Disjunctive Syllogism
+- Denying Antecedent
+- Invalid Conditional Syllogism
+
+Each argument was constructed by selecting two random propositions (from a list of 400 propositions that was generated beforehand), choosing a type of argument and combining it all with randomly selected connectors (therefore, since, hence, thus, etc).
+
+50k arguments were created to train the model, and 100 to test.
+
+### 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
+
+[More Information Needed]
+We converted the data to the Alpaca chat format before feeding it to the model.
+
+#### Training
+
+We used unsloth for memory reduced sped up training.
+
+We trained for one epoch.
+
+Less than 2.5 GB of VRAM were used for training, and it took 2.5 hours.
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+The model obtains 100% train and test accuracy on our synthetic dataset.