Update README.md

README.md

@@ -11,52 +11,87 @@ tags:
 licence: license
 pipeline_tag: text-generation
 ---
+ 
+# code: 
 
-# Model Card for fol-parser-phi2-lora
-
-This model is a fine-tuned version of [microsoft/phi-2](https://huggingface.co/microsoft/phi-2).
-It has been trained using [TRL](https://github.com/huggingface/trl).
+```python
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
 
-## Quick start
+BASE_MODEL = "microsoft/phi-2"
+ADAPTER_MODEL = "MinaGabriel/fol-parser-phi2-lora-adapter"
 
-```python
-from transformers import pipeline
+# tokenizer
+tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
+ 
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token 
+ 
+base_model = AutoModelForCausalLM.from_pretrained(
+    BASE_MODEL,
+    torch_dtype=torch.float16,     
+    device_map="auto",
+)
+ 
+base_model.config.pad_token_id = tokenizer.pad_token_id
+base_model.generation_config.pad_token_id = tokenizer.pad_token_id
+# attach the adapter
+model = PeftModel.from_pretrained(
+    base_model,
+    ADAPTER_MODEL,
+    device_map="auto",
+)
+model.eval()
 
-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="None", device="cuda")
-output = generator([{"role": "user", "content": question}], max_new_tokens=128, return_full_text=False)[0]
-print(output["generated_text"])
-```
+def generate(context: str, question: str, max_new_tokens: int = 300) -> str:
+    prompt = (
+        "<SYS>\nYou are a precise logic parser. Output [FOL] then [CONCLUSION_FOL].\n</SYS>\n"
+        "<USER>\n"
+        f"[CONTEXT]\n{context}\n\n"
+        f"[QUESTION]\n{question}\n\n"
+        "Produce the two blocks exactly as specified.\n"
+        "</USER>\n"
+        "<ASSISTANT>\n"
+    )
 
-## Training procedure
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
 
- 
+    with torch.no_grad():
+        output_ids = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            do_sample=False,
+            temperature=0.0,
+            eos_token_id=tokenizer.eos_token_id,      # explicit
+            pad_token_id=tokenizer.pad_token_id       # explicit
+        )
 
+    full_text = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+    return full_text.split("<ASSISTANT>\n")[-1].strip()
 
-This model was trained with SFT.
+```
 
-### Framework versions
+# Usage:
 
-- PEFT 0.17.1
-- TRL: 0.23.1
-- Transformers: 4.57.0
-- Pytorch: 2.8.0+cu126
-- Datasets: 4.0.0
-- Tokenizers: 0.22.1
+```python
+print(
+    generate(
+        context="Cats are animal. dogs are animal. human are not animal. animal are awsome",
+        question="dogs awsome?"
+    )
+)
+```
 
-## Citations
 
+# output: 
 
+[FOL]
+cat(animal)
+dog(animal)
+¬human(animal)
+∀x (animal(x) → awsome(x))
 
-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{\'e}dec},
-	year         = 2020,
-	journal      = {GitHub repository},
-	publisher    = {GitHub},
-	howpublished = {\url{https://github.com/huggingface/trl}}
-}
-```
+[CONCLUSION_FOL]
+awesome(dog)
+</ASSISTANT>