ok

generative_inference.py

@@ -1,6 +1,7 @@
 import torch
 import json
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+from transformers import AutoModelForCausalLM, AutoTokenizer
 from peft import PeftModel
 import openai
 
@@ -36,8 +37,14 @@ MODEL_OPTIONS = {
                "model_id": "ft:gpt-3.5-turbo-0125:asma:gpt-3-5-turbo-absa:Bb6gmwkE"},
     "GPT4o": {"base": "openai/gpt-4o",
               "model_id": "ft:gpt-4o-mini-2024-07-18:asma:gpt4-finetune-absa:BazoEjnp"},
-    "DeepSeek": { "base": "deepseek-ai/deepseek-llm-7b-chat", "adapter": "asmashayea/deepseek-absa" }
-
+    "ALLaM": {
+        "base": "ALLaM-AI/ALLaM-7B-Instruct-preview",
+        "adapter": "asmashayea/allam-absa"
+    },
+    "DeepSeek": {
+        "base": "deepseek-ai/deepseek-llm-7b-chat",
+        "adapter": "asmashayea/deepseek-absa"
+    }
 }
 
 
@@ -111,26 +118,94 @@ def infer_gpt_absa(text, model_key):
 
 
 
-from transformers import AutoModelForCausalLM, AutoTokenizer
+def infer_allam(review_text):
+    tokenizer, model = cached_models.get("ALLaM") or load_allam()
 
-def load_deepseek():
+    prompt = tokenizer.apply_chat_template(
+        [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": review_text}
+        ],
+        tokenize=False
+    )
+
+    inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512).to(model.device)
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=128,
+            do_sample=False,
+            temperature=0.0,
+            pad_token_id=tokenizer.eos_token_id
+        )
+
+    decoded = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True).strip()
+    try:
+        parsed = json.loads(decoded)
+        return parsed
+    except Exception as e:
+        return {"error": str(e), "raw": decoded}
+
+
+def load_allam():
     base_model = AutoModelForCausalLM.from_pretrained(
-        MODEL_OPTIONS["DeepSeek"]["base"],
+        MODEL_OPTIONS["ALLaM"]["base"],
         device_map="auto",
         torch_dtype=torch.float16,
         trust_remote_code=True
     )
     tokenizer = AutoTokenizer.from_pretrained(
-        MODEL_OPTIONS["DeepSeek"]["adapter"],
+        MODEL_OPTIONS["ALLaM"]["adapter"],
         trust_remote_code=True
     )
-    model = PeftModel.from_pretrained(base_model, MODEL_OPTIONS["DeepSeek"]["adapter"])
+    model = PeftModel.from_pretrained(base_model, MODEL_OPTIONS["ALLaM"]["adapter"])
 
-    cached_models["DeepSeek"] = (tokenizer, model)
+    cached_models["ALLaM"] = (tokenizer, model)
     return tokenizer, model
 
 
 
+
+
+def load_allam():
+    base = AutoModelForCausalLM.from_pretrained(
+        MODEL_OPTIONS["ALLaM"]["base"],
+        torch_dtype=torch.float16,
+        trust_remote_code=True
+    )
+    tokenizer = AutoTokenizer.from_pretrained(
+        MODEL_OPTIONS["ALLaM"]["adapter"], trust_remote_code=True
+    )
+    model = PeftModel.from_pretrained(base, MODEL_OPTIONS["ALLaM"]["adapter"])
+    cached_models["ALLaM"] = (tokenizer, model)
+    return tokenizer, model
+
+def infer_allam(review):
+    if "ALLaM" not in cached_models:
+        tokenizer, model = load_allam()
+    else:
+        tokenizer, model = cached_models["ALLaM"]
+
+    prompt = tokenizer.apply_chat_template([
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": review}
+    ], tokenize=False)
+
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+
+    with torch.no_grad():
+        output = model.generate(**inputs, max_new_tokens=256)
+    decoded = tokenizer.decode(output[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
+
+    try:
+        return json.loads(decoded)
+    except:
+        return decoded
+
+
+
+
 def build_deepseek_prompt(review_text, output=""):
     return f"""<|system|>
 You are an advanced AI model specialized in extracting aspects and determining their sentiment polarity from customer reviews.
@@ -152,15 +227,30 @@ Instructions:
 {output}"""  # ✅ include the output here
 
 
+def load_deepseek():
+    base = AutoModelForCausalLM.from_pretrained(
+        MODEL_OPTIONS["DeepSeek"]["base"],
+        torch_dtype=torch.float16,
+        trust_remote_code=True
+    )
+    tokenizer = AutoTokenizer.from_pretrained(
+        MODEL_OPTIONS["DeepSeek"]["adapter"], trust_remote_code=True
+    )
+    model = PeftModel.from_pretrained(base, MODEL_OPTIONS["DeepSeek"]["adapter"])
+    cached_models["DeepSeek"] = (tokenizer, model)
+    return tokenizer, model
 
-def infer_deepseek(text):
-    tokenizer, model = cached_models.get("DeepSeek") or load_deepseek()
+def infer_deepseek(review):
+    if "DeepSeek" not in cached_models:
+        tokenizer, model = load_deepseek()
+    else:
+        tokenizer, model = cached_models["DeepSeek"]
 
-    prompt = build_deepseek_prompt(text)
+    prompt = build_deepseek_prompt(review)
     inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512).to(model.device)
 
     with torch.no_grad():
-        outputs = model.generate(
+        output = model.generate(
             **inputs,
             max_new_tokens=128,
             do_sample=False,
@@ -168,9 +258,16 @@ def infer_deepseek(text):
             pad_token_id=tokenizer.eos_token_id
         )
 
-    decoded = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True).strip()
+    decoded = tokenizer.decode(
+        output[0][inputs["input_ids"].shape[1]:],
+        skip_special_tokens=True
+    ).strip()
+
     try:
-        parsed = json.loads(decoded)
-        return parsed
+        return json.loads(decoded)
     except Exception as e:
-        return {"error": str(e), "raw": decoded}
+        print(f"❌ DeepSeek JSON parse error: {e}")
+        return decoded
+
+
+

inference.py

@@ -3,7 +3,7 @@ import json
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModel, AutoConfig
 from peft import LoraConfig, get_peft_model, PeftModel
 from modeling_bilstm_crf import BERT_BiLSTM_CRF
-from generative_inference import infer_t5_bart, infer_gpt_absa, infer_deepseek
+from generative_inference import infer_t5_bart, infer_gpt_absa, infer_deepseek, infer_allam
 from huggingface_hub import hf_hub_download
 
 # Define supported models and their adapter IDs
@@ -24,7 +24,14 @@ MODEL_OPTIONS = {
                "model_id": "ft:gpt-3.5-turbo-0125:asma:gpt-3-5-turbo-absa:Bb6gmwkE"},
     "GPT4o": {"base": "openai/gpt-4o",
               "model_id": "ft:gpt-4o-mini-2024-07-18:asma:gpt4-finetune-absa:BazoEjnp"},
-    "DeepSeek": { "base": "deepseek-ai/deepseek-llm-7b-chat", "adapter": "deepseek7bchat-json-lora-gptparam" }
+    "ALLaM": {
+        "base": "ALLaM-AI/ALLaM-7B-Instruct-preview",
+        "adapter": "asmashayea/allam-absa"
+    },
+    "DeepSeek": {
+        "base": "deepseek-ai/deepseek-llm-7b-chat",
+        "adapter": "asmashayea/deepseek-absa"
+    }
 }
 
 
@@ -142,5 +149,8 @@ def predict_absa(text, model_choice):
 
     elif model_choice == "DeepSeek":
         return infer_deepseek(text)
+    
+    elif model_choice == "ALLaM":
+        return infer_allam(text)
 
     return decoded