diff --git a/evaluation/baseline/common_finetune_sft.py b/evaluation/baseline/common_finetune_sft.py
new file mode 100644
index 00000000..74189bd5
--- /dev/null
+++ b/evaluation/baseline/common_finetune_sft.py
@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""
+Common SFT (LoRA) fine-tuning helper for HF Image-Text-to-Text models.
+Exposes run_sft(train_examples, **kwargs) where each example is a dict with a
+"messages" field (chat template) and optional images embedded in the messages.
+
+Dependencies:
+  transformers, datasets, peft, trl, accelerate (and bitsandbytes if you want QLoRA)
+"""
+from __future__ import annotations
+import io
+import os
+import sys
+from typing import List
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
+import wfdb
+from datasets import Dataset
+from transformers import AutoModelForImageTextToText, AutoProcessor
+import torch
+from peft import LoraConfig
+from trl import SFTTrainer
+from trl.trainer.sft_config import SFTConfig
+from PIL import Image
+
+# Ensure project src/ is on sys.path so we can import time_series_datasets
+PROJECT_SRC = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "src"))
+if PROJECT_SRC not in sys.path:
+    sys.path.insert(0, PROJECT_SRC)
+
+from time_series_datasets.ecg_qa.plot_example import get_ptbxl_ecg_path
+
+LEAD_NAMES = ["I", "II", "III", "aVR", "aVL", "aVF", "V1", "V2", "V3", "V4", "V5", "V6"]
+
+
+def _downsample_to_100hz(ecg_data: np.ndarray, original_freq: int) -> np.ndarray:
+    """Downsample ECG data to 100Hz"""
+    if original_freq == 100:
+        return ecg_data
+
+    # Calculate downsampling factor
+    downsample_factor = original_freq // 100
+
+    # Downsample by taking every nth sample
+    downsampled_data = ecg_data[::downsample_factor]
+
+    return downsampled_data
+
+
+def _load_ecg_data(ecg_id: int) -> np.ndarray:
+    """Load ECG data for a given ECG ID using wfdb."""
+    ecg_path = get_ptbxl_ecg_path(ecg_id)
+
+    if not os.path.exists(ecg_path + ".dat"):
+        raise FileNotFoundError(f"ECG file not found: {ecg_path}.dat")
+
+    # Read ECG data using wfdb - returns (samples, leads) shape
+    ecg_data, meta = wfdb.rdsamp(ecg_path)
+
+    return ecg_data
+
+
+def _ecg_to_image(ecg_data: np.ndarray) -> Image.Image:
+    """Render ECG data to PIL Image (for lazy loading in collate_fn)."""
+
+    # Downsample to 100Hz if needed
+    if ecg_data.shape[0] > 1000:  # Likely 500Hz data
+        ecg_data = _downsample_to_100hz(ecg_data, 500)
+
+    n = min(ecg_data.shape[1], 12)  # Up to 12 leads
+    fig, axes = plt.subplots(n, 1, figsize=(10.5, 1.5 * n), dpi=80)
+    if n == 1:
+        axes = [axes]
+
+    # Create time array for 100Hz sampling (10 seconds)
+    time_points = np.arange(0, 10, 0.01)  # 100Hz for 10 seconds
+
+    for i in range(n):
+        ax = axes[i]
+        lead_name = LEAD_NAMES[i] if i < len(LEAD_NAMES) else f"Lead {i+1}"
+
+        # Plot the ECG signal for this lead - ecg_data is (samples, leads)
+        ax.plot(time_points, ecg_data[:, i], linewidth=2, color="k", alpha=1.0)
+
+        # Add grid lines (millimeter paper style)
+        # Major grid lines (every 0.2s and 0.5mV)
+        ax.vlines(
+            np.arange(0, 10, 0.2), -2.5, 2.5, colors="r", alpha=0.3, linewidth=0.5
+        )
+        ax.hlines(
+            np.arange(-2.5, 2.5, 0.5), 0, 10, colors="r", alpha=0.3, linewidth=0.5
+        )
+
+        # Minor grid lines (every 0.04s and 0.1mV)
+        ax.vlines(
+            np.arange(0, 10, 0.04), -2.5, 2.5, colors="r", alpha=0.1, linewidth=0.3
+        )
+        ax.hlines(
+            np.arange(-2.5, 2.5, 0.1), 0, 10, colors="r", alpha=0.1, linewidth=0.3
+        )
+
+        ax.set_xticks(np.arange(0, 11, 1.0))
+        ax.set_ylabel(f"Lead {lead_name} (mV)", fontweight="bold")
+        ax.margins(0.0)
+        ax.set_ylim(-2.5, 2.5)
+        ax.set_title(f"Lead {lead_name}", fontweight="bold", pad=10)
+
+    plt.tight_layout()
+
+    canvas = FigureCanvas(fig)
+    buf = io.BytesIO()
+    canvas.print_png(buf)
+    plt.close(fig)
+
+    # Return PIL Image directly
+    buf.seek(0)
+    return Image.open(buf).convert("RGB")
+
+
+def process_vision_info(messages: list[dict]) -> list[Image.Image]:
+    """Extract PIL images from chat messages. Handles lazy ecg_id, bytes, and PIL Images."""
+    image_inputs = []
+    for msg in messages:
+        content = msg.get("content", [])
+        if not isinstance(content, list):
+            content = [content]
+
+        for element in content:
+            if not isinstance(element, dict):
+                continue
+
+            # Handle lazy ecg_id reference (render on-demand)
+            ecg_id = element.get("ecg_id")
+            if ecg_id is not None:
+                ecg_data = _load_ecg_data(ecg_id)
+                image = _ecg_to_image(ecg_data)
+                image_inputs.append(image)
+                continue
+
+            # Handle pre-rendered bytes (backwards compatibility)
+            image = element.get("image")
+            if image is None:
+                continue  # Text elements get "image": None from Dataset serialization
+
+            # Handle bytes (PNG data) - convert to PIL Image
+            if isinstance(image, bytes):
+                image = Image.open(io.BytesIO(image))
+
+            image_inputs.append(image.convert("RGB"))
+    return image_inputs
+
+
+def run_sft(
+    train_examples: List[dict],
+    *,
+    output_dir: str,
+    llm_id: str = "google/gemma-3-4b-pt",
+    epochs: int = 1,
+    learning_rate: float = 2e-4,
+    per_device_train_batch_size: int = 1,
+    gradient_accumulation_steps: int = 4,
+    max_seq_len: int = 4096,
+    logging_steps: int = 10,
+    save_steps: int = 500,  # Save less frequently to save disk space
+    bf16: bool = True,
+) -> None:
+    """Run LoRA SFT on chat-style examples (with images) and save adapters.
+
+    Args:
+        train_examples: List of dicts, each containing a "messages" list compatible
+            with the processor's chat template. Image elements should be PIL Images
+            placed as dicts with {"type": "image", "image": PIL.Image}.
+        output_dir: Where to save adapters and processor
+        llm_id: HF model id (e.g., google/gemma-3-4b-pt)
+        epochs, learning_rate, per_device_train_batch_size, gradient_accumulation_steps,
+        max_seq_len: Usual training hyperparameters
+        logging_steps, save_steps, bf16: Trainer settings
+    """
+    if not train_examples:
+        raise ValueError("train_examples is empty; provide at least one training example")
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    ds = Dataset.from_list(train_examples)
+
+    processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
+
+    model = AutoModelForImageTextToText.from_pretrained(
+        llm_id,
+        attn_implementation="flash_attention_2",
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        low_cpu_mem_usage=True,
+    )
+
+    lora_cfg = LoraConfig(
+        lora_alpha=8,
+        lora_dropout=0.05,
+        r=8,
+        bias="none",
+        target_modules="all-linear",
+        task_type="CAUSAL_LM",
+        modules_to_save=["lm_head", "embed_tokens"],
+    )
+
+    training_args = SFTConfig(
+        output_dir=output_dir,
+        num_train_epochs=epochs,
+        per_device_train_batch_size=per_device_train_batch_size,
+        gradient_accumulation_steps=gradient_accumulation_steps,
+        learning_rate=learning_rate,
+        logging_steps=logging_steps,
+        save_strategy="steps",
+        save_steps=save_steps,
+        bf16=bf16,
+        report_to=[],
+        dataset_text_field="",
+        dataset_kwargs={"skip_prepare_dataset": True},
+        max_seq_length=max_seq_len,
+        packing=False,
+        remove_unused_columns=False,
+        gradient_checkpointing=True,
+        gradient_checkpointing_kwargs={"use_reentrant": False},
+        optim="adamw_8bit",
+        max_grad_norm=0.3,
+    )
+
+    def collate_fn(examples: List[dict]):
+        """Collate chat examples into a batch with masked labels."""
+        texts = []
+        images = []
+        for ex in examples:
+            msgs = ex["messages"]
+            text = processor.apply_chat_template(
+                msgs, add_generation_prompt=False, tokenize=False
+            )
+            texts.append(text.strip())
+            images.append(process_vision_info(msgs))
+
+        batch = processor(text=texts, images=images, return_tensors="pt", padding=True)
+
+        labels = batch["input_ids"].clone()
+
+        pad_token_id = processor.tokenizer.pad_token_id
+        if pad_token_id is not None:
+            labels[labels == pad_token_id] = -100
+
+        special_map = processor.tokenizer.special_tokens_map
+        boi_id = None
+        if isinstance(special_map, dict) and "boi_token" in special_map:
+            boi_id = processor.tokenizer.convert_tokens_to_ids(special_map["boi_token"])
+        if boi_id is not None:
+            labels[labels == boi_id] = -100
+        labels[labels == 262144] = -100
+
+        batch["labels"] = labels
+        return batch
+
+    trainer = SFTTrainer(
+        model=model,
+        peft_config=lora_cfg,
+        processing_class=processor,
+        train_dataset=ds,
+        args=training_args,
+        data_collator=collate_fn,
+    )
+
+    resume_from_checkpoint = None
+    import glob
+    import os as os_module
+    checkpoints = glob.glob(f"{output_dir}/checkpoint-*")
+    if checkpoints:
+        latest_checkpoint = max(checkpoints, key=lambda x: int(x.split("-")[-1]))
+        if os_module.path.exists(os_module.path.join(latest_checkpoint, "trainer_state.json")):
+            resume_from_checkpoint = latest_checkpoint
+            print(f"Resuming from checkpoint: {resume_from_checkpoint}")
+        else:
+            print(f"Checkpoint {latest_checkpoint} is incomplete, starting from scratch")
+
+    trainer.train(resume_from_checkpoint=resume_from_checkpoint)
+    trainer.model.save_pretrained(output_dir)
+    processor.save_pretrained(output_dir)
+    print(f"Saved LoRA adapters and processor to: {output_dir}")
+
+    del model
+    del trainer
+    torch.cuda.empty_cache()
+
diff --git a/evaluation/baseline/evaluate_ecg_qa.py b/evaluation/baseline/evaluate_ecg_qa.py
index 5c657d96..32c06e9b 100644
--- a/evaluation/baseline/evaluate_ecg_qa.py
+++ b/evaluation/baseline/evaluate_ecg_qa.py
@@ -6,13 +6,56 @@
 # SPDX-License-Identifier: MIT
 #
 
+import ast
+import os
 import re
 import sys
-from typing import Dict, Any, List, Tuple
+from typing import Dict, Any, List, Optional, Tuple
 
+import pandas as pd
 
-from common_evaluator import CommonEvaluator
-from time_series_datasets.ecg_qa.ECGQACoTQADataset import ECGQACoTQADataset
+# Add src directory to path for time_series_datasets imports
+_SRC_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "src")
+sys.path.insert(0, _SRC_DIR)
+
+# Template answers cache - loaded from CSV on first access
+_template_answers_cache: Optional[Dict[int, List[str]]] = None
+
+
+def _load_template_answers_cache() -> Dict[int, List[str]]:
+    """Load template answers from CSV file."""
+    global _template_answers_cache
+    if _template_answers_cache is None:
+        # Path relative to this file: ../../data/ecg_qa/ecgqa/mimic-iv-ecg/answers_for_each_template.csv
+        base_dir = os.path.dirname(os.path.abspath(__file__))
+        template_answers_path = os.path.join(
+            base_dir, "..", "..", "data", "ecg_qa", "ecgqa", "mimic-iv-ecg", "answers_for_each_template.csv"
+        )
+
+        if not os.path.exists(template_answers_path):
+            raise FileNotFoundError(
+                f"Template answers file not found at {template_answers_path}. "
+                "Please ensure the ECG-QA dataset is downloaded."
+            )
+
+        template_df = pd.read_csv(template_answers_path)
+        _template_answers_cache = {}
+        for _, row in template_df.iterrows():
+            template_id = int(row['template_id'])
+            answers_str = row['classes']
+            try:
+                _template_answers_cache[template_id] = ast.literal_eval(answers_str)
+            except Exception as e:
+                print(f"Warning: Failed to parse answers for template {template_id}: {e}")
+                _template_answers_cache[template_id] = []
+
+    return _template_answers_cache
+
+
+def get_possible_answers_for_template(template_id: int) -> List[str]:
+    """Get possible answers for a specific template ID."""
+    cache = _load_template_answers_cache()
+    return cache.get(template_id, [])
 
 
 def extract_answer(text: str) -> str:
@@ -40,7 +83,7 @@ def normalize_label(label: str) -> str:
 
 
 def evaluate_ecg_metrics(
-    ground_truth: str, prediction: str, sample: Dict[str, Any] | None = None
+    ground_truth: str, prediction: str, sample: Optional[Dict[str, Any]] = None
 ) -> Dict[str, Any]:
     """
     Evaluate ECG-QA CoT predictions using per-template answers from CSV.
@@ -68,11 +111,22 @@ def evaluate_ecg_metrics(
         print(f"DEBUG: Sample content: {sample}")
         raise ValueError("Missing 'template_id' in sample for ECG-QA evaluation")
 
-    possible_answers = ECGQACoTQADataset.get_possible_answers_for_template(
-        int(template_id)
-    )
+    possible_answers = get_possible_answers_for_template(int(template_id))
     if not possible_answers:
-        raise ValueError(f"No possible answers found for template_id={template_id}")
+        # Template not found in answers file - return metrics indicating this
+        return {
+            "accuracy": 0,
+            "f1_score": 0.0,
+            "precision": 0.0,
+            "recall": 0.0,
+            "prediction_normalized": pred_norm,
+            "ground_truth_normalized": gt_norm,
+            "prediction_supported": False,
+            "ground_truth_supported": False,
+            "template_id": template_id,
+            "possible_answers": [],
+            "template_missing": True,
+        }
 
     possible_answers_lower = [a.lower().strip() for a in possible_answers]
 
@@ -121,13 +175,16 @@ def _calculate_template_f1_stats(data_points: List[Dict[str, Any]]) -> Dict[str,
     total_correct = 0
     total_f1_sum = 0.0
 
+    skipped_templates = []
     for template_id, points in template_groups.items():
         if not points:
             continue
 
         possible_answers = points[0].get("possible_answers", [])
         if not possible_answers:
-            raise ValueError(f"No possible answers found for template {template_id}")
+            # Template missing from answers file - skip but track for warning
+            skipped_templates.append((template_id, len(points)))
+            continue
 
         # Initialize per-class counts
         class_predictions: Dict[str, Dict[str, int]] = {}
@@ -205,6 +262,9 @@ def _calculate_template_f1_stats(data_points: List[Dict[str, Any]]) -> Dict[str,
     overall_accuracy = total_correct / total_samples if total_samples > 0 else 0.0
     overall_avg_f1 = total_f1_sum / total_samples if total_samples > 0 else 0.0
 
+    # Report skipped templates
+    skipped_samples = sum(count for _, count in skipped_templates)
+
     return {
         "overall": {
             "total_samples": total_samples,
@@ -212,8 +272,11 @@ def _calculate_template_f1_stats(data_points: List[Dict[str, Any]]) -> Dict[str,
             "accuracy": overall_accuracy,
             "average_f1": overall_avg_f1,
             "macro_f1": overall_macro_f1,
+            "skipped_templates": len(skipped_templates),
+            "skipped_samples": skipped_samples,
         },
         "per_template": template_stats,
+        "skipped_template_details": skipped_templates,
     }
 
 
@@ -248,6 +311,9 @@ def _build_data_points_from_results(
 
 def main():
     """Main function to run ECG-QA CoT evaluation with parser-matching F1 aggregation."""
+    from common_evaluator import CommonEvaluator
+    from time_series_datasets.ecg_qa.ECGQACoTQADataset import ECGQACoTQADataset
+
     if len(sys.argv) != 2:
         print("Usage: python evaluate_ecg_qa.py <model_name>")
         print("Example: python evaluate_ecg_qa.py meta-llama/Llama-3.2-1B")
diff --git a/evaluation/baseline/evaluate_ecg_qa_results.py b/evaluation/baseline/evaluate_ecg_qa_results.py
new file mode 100644
index 00000000..978179e3
--- /dev/null
+++ b/evaluation/baseline/evaluate_ecg_qa_results.py
@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Evaluate ECG-QA inference results from a CSV file.
+Reuses evaluation logic from evaluate_ecg_qa.py.
+"""
+import argparse
+import pandas as pd
+
+from evaluate_ecg_qa import (
+    evaluate_ecg_metrics,
+    _calculate_template_f1_stats,
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Evaluate ECG-QA inference results from CSV")
+    parser.add_argument("csv_path", type=str, help="Path to inference results CSV")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Show per-sample details")
+    args = parser.parse_args()
+
+    # Load CSV
+    df = pd.read_csv(args.csv_path)
+    print(f"Loaded {len(df)} samples from {args.csv_path}\n")
+
+    # Evaluate each sample using imported function
+    data_points = []
+    for _, row in df.iterrows():
+        sample = {"template_id": row["template_id"]}
+        metrics = evaluate_ecg_metrics(
+            row["target_answer"],
+            row["generated_answer"],
+            sample
+        )
+        data_points.append(metrics)
+
+    # Aggregate using imported function
+    f1_stats = _calculate_template_f1_stats(data_points)
+
+    # Print results
+    overall = f1_stats.get("overall", {})
+    print("=" * 80)
+    print("EVALUATION RESULTS")
+    print("=" * 80)
+    print(f"Total samples evaluated: {overall.get('total_samples', 0)}")
+    print(f"Accuracy: {overall.get('accuracy', 0):.4f}")
+    print(f"Average F1 Score: {overall.get('average_f1', 0):.4f}")
+    print(f"Macro-F1 Score: {overall.get('macro_f1', 0):.4f}")
+
+    # Report skipped templates
+    skipped_templates = overall.get('skipped_templates', 0)
+    skipped_samples = overall.get('skipped_samples', 0)
+    if skipped_templates > 0:
+        print(f"\nWarning: Skipped {skipped_templates} templates ({skipped_samples} samples) due to missing answers")
+        skipped_details = f1_stats.get("skipped_template_details", [])
+        for template_id, count in skipped_details:
+            print(f"  Template {template_id}: {count} samples skipped")
+
+    # Per-template stats
+    per_template = f1_stats.get("per_template", {})
+    if per_template:
+        print(f"\nPer-Template Statistics:")
+        for template_id, stats in sorted(per_template.items()):
+            print(f"  Template {template_id}:")
+            print(f"    Samples: {stats['num_samples']}")
+            print(f"    Accuracy: {stats['accuracy']:.4f}")
+            print(f"    Macro-F1: {stats['macro_f1']:.4f}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/evaluation/baseline/evaluate_har_plot.py b/evaluation/baseline/evaluate_har_plot.py
index 05cecd13..e2dd5bf0 100644
--- a/evaluation/baseline/evaluate_har_plot.py
+++ b/evaluation/baseline/evaluate_har_plot.py
@@ -8,7 +8,6 @@
 
 import re
 import sys
-import argparse
 import io
 import base64
 from typing import Dict, Any
@@ -16,46 +15,29 @@
 import matplotlib.pyplot as plt
 
 from common_evaluator_plot import CommonEvaluatorPlot
-from time_series_datasets.pamap2.PAMAP2AccQADataset import PAMAP2AccQADataset
 from time_series_datasets.har_cot.HARAccQADataset import HARAccQADataset
 
 def extract_label_from_prediction(prediction: str) -> str:
-    """
-    Extract the label from the model's prediction.
-    - If 'Answer:' is present, take everything after the last 'Answer:'
-    - Otherwise, take the last word
-    - Strips whitespace and punctuation
-    """
+    """Extract the label from the model's prediction."""
     pred = prediction.strip()
-    # Find the last occurrence of 'Answer:' (case-insensitive)
     match = list(re.finditer(r'answer:\s*', pred, re.IGNORECASE))
     if match:
-        # Take everything after the last 'Answer:'
-        start = match[-1].end()
-        label = pred[start:].strip()
+        label = pred[match[-1].end():].strip()
     else:
-        # Take the last word
         label = pred.split()[-1] if pred.split() else ''
-    # Remove trailing punctuation (e.g., period, comma)
     label = re.sub(r'[\.,;:!?]+$', '', label)
     return label.lower()
 
 
 def evaluate_har_acc(ground_truth: str, prediction: str) -> Dict[str, Any]:
-    """
-    Evaluate HARAccQADataset predictions against ground truth.
-    Extracts the label from the end of the model's output and compares to ground truth.
-    """
+    """Evaluate HARAccQADataset predictions against ground truth."""
     gt_clean = ground_truth.lower().strip()
     pred_label = extract_label_from_prediction(prediction)
-    accuracy = int(gt_clean == pred_label)
-    return {"accuracy": accuracy}
+    return {"accuracy": int(gt_clean == pred_label)}
 
 
 def generate_time_series_plot(time_series) -> str:
-    """
-    Create a base64 PNG plot from a list/tuple of 1D numpy arrays (e.g., [x, y, z]).
-    """
+    """Create a base64 PNG plot from accelerometer data [x, y, z]."""
     if time_series is None:
         return None
     ts_list = list(time_series)
@@ -69,7 +51,9 @@ def generate_time_series_plot(time_series) -> str:
     for i, series in enumerate(ts_list):
         axes[i].plot(series, marker='o', linestyle='-', markersize=0)
         axes[i].grid(True, alpha=0.3)
-        axes[i].set_title(f"Accelerometer - {axis_names.get(i, f'Axis {i+1}')}" )
+        axes[i].set_title(f"Accelerometer - {axis_names.get(i, f'Axis {i+1}')}")
+        axes[i].set_ylabel("Acceleration (g)")
+    axes[-1].set_xlabel("Time (samples)")
 
     plt.tight_layout()
 
@@ -103,7 +87,7 @@ def main():
         dataset_classes=dataset_classes,
         evaluation_functions=evaluation_functions,
         plot_functions=plot_functions,
-        max_samples=None,  # Limit for faster testing, set to None for full evaluation,
+        max_samples=None,
         max_new_tokens=400,
     )
     print("\n" + "="*80)
diff --git a/evaluation/baseline/evaluate_sleep_plot.py b/evaluation/baseline/evaluate_sleep_plot.py
index ca71f0c8..8751598b 100644
--- a/evaluation/baseline/evaluate_sleep_plot.py
+++ b/evaluation/baseline/evaluate_sleep_plot.py
@@ -13,67 +13,49 @@
 from typing import Dict, Any
 
 import matplotlib.pyplot as plt
-import numpy as np
 
 from common_evaluator_plot import CommonEvaluatorPlot
 from time_series_datasets.sleep.SleepEDFCoTQADataset import SleepEDFCoTQADataset
 
 
 def extract_label_from_text(text: str) -> str:
-    """
-    Extract the label from a free-form rationale or prediction text.
-    - If 'Answer:' is present (case-insensitive), take everything after the last 'Answer:'
-    - Otherwise, take the last word
-    - Strip whitespace and trailing punctuation
-    - Lowercase for comparison
-    """
+    """Extract the label from a prediction or rationale text."""
     if text is None:
         return ""
     pred = text.strip()
     matches = list(re.finditer(r"answer:\s*", pred, re.IGNORECASE))
     if matches:
-        start = matches[-1].end()
-        label = pred[start:].strip()
+        label = pred[matches[-1].end():].strip()
     else:
         label = pred.split()[-1] if pred.split() else ""
     label = re.sub(r"[\.,;:!?]+$", "", label)
     return label.lower()
 
 
-def evaluate_sleep_stage(
-    ground_truth_text: str, prediction_text: str
-) -> Dict[str, Any]:
-    """
-    Evaluate SleepEDFCoTQADataset predictions against ground truth.
-    For SleepEDF, the dataset's "answer" is a rationale ending with 'Answer: <label>'.
-    We therefore extract the label from BOTH ground truth and prediction and compare.
-    """
+def evaluate_sleep_stage(ground_truth_text: str, prediction_text: str) -> Dict[str, Any]:
+    """Evaluate SleepEDFCoTQADataset predictions against ground truth."""
     gt_label = extract_label_from_text(ground_truth_text)
     pred_label = extract_label_from_text(prediction_text)
-    accuracy = int(gt_label == pred_label)
-    return {"accuracy": accuracy, "gt_label": gt_label, "pred_label": pred_label}
+    return {"accuracy": int(gt_label == pred_label), "gt_label": gt_label, "pred_label": pred_label}
 
 
 def generate_time_series_plot(time_series) -> str:
-    """
-    Create a base64 PNG plot from one or more time series.
-    - Accepts a single 1D array/list or a collection of 1D arrays/lists.
-    - If a 2D numpy array is provided, each row is treated as a separate series.
-    """
+    """Create a base64 PNG plot from the first channel (EEG) of a time series."""
     if time_series is None:
         return None
     ts_list = list(time_series)
 
-    num_series = len(ts_list)
-    fig, axes = plt.subplots(num_series, 1, figsize=(10, 4 * num_series), sharex=True)
-    if num_series == 1:
-        axes = [axes]
+    if len(ts_list) > 0 and hasattr(ts_list[0], "__len__"):
+        eeg = ts_list[0]
+    else:
+        eeg = ts_list
 
-    axis_names = {0: "EEG", 1: "EOG", 2: "EMG"}
-    for i, series in enumerate(ts_list):
-        axes[i].plot(series, marker="o", linestyle="-", markersize=0)
-        axes[i].grid(True, alpha=0.3)
-        axes[i].set_title(f"{axis_names.get(i, f'Axis {i + 1}')}")
+    fig, ax = plt.subplots(figsize=(10, 4))
+    ax.plot(eeg, marker="o", linestyle="-", markersize=0)
+    ax.grid(True, alpha=0.3)
+    ax.set_title("EEG")
+    ax.set_ylabel("Amplitude")
+    ax.set_xlabel("Time (samples)")
 
     plt.tight_layout()
 
@@ -108,7 +90,7 @@ def main():
         dataset_classes=dataset_classes,
         evaluation_functions=evaluation_functions,
         plot_functions=plot_functions,
-        max_samples=None,  # Set to None for full evaluation
+        max_samples=None,
         max_new_tokens=400,
     )
 
diff --git a/evaluation/baseline/evaluate_sleep_results.py b/evaluation/baseline/evaluate_sleep_results.py
new file mode 100644
index 00000000..06bbe35f
--- /dev/null
+++ b/evaluation/baseline/evaluate_sleep_results.py
@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+"""
+Evaluate sleep inference results from a CSV file.
+Reuses evaluation logic from parse_sleep_cot_data.py.
+"""
+import argparse
+import re
+from typing import Dict, Any, List
+
+import pandas as pd
+
+# Standard sleep stage labels (from SleepEDFCoTQADataset)
+FALLBACK_LABELS = [
+    "Wake",
+    "Non-REM stage 1",
+    "Non-REM stage 2",
+    "Non-REM stage 3",
+    "REM sleep",
+    "Movement",
+]
+SUPPORTED_LABELS: List[str] = []
+
+
+def _canonicalize_label(text: str) -> tuple:
+    """Return canonical label with stage 4 merged into stage 3.
+
+    Handles both short labels (W, N1, N2, N3, N4, REM) and long labels
+    (Wake, Non-REM stage 1, etc.).
+
+    - Case-insensitive
+    - Trims whitespace and trailing punctuation
+    - Merges stage 4 into stage 3
+    - Returns (canonical_label_str, is_supported_bool)
+    """
+    if text is None:
+        return "", False
+
+    cleaned = str(text).strip()
+    # Remove any end-of-text tokens and trailing punctuation
+    cleaned = re.sub(r'<\|.*?\|>|<eos>$', '', cleaned).strip()
+    cleaned = re.sub(r'[\.,;:!?]+$', '', cleaned).strip()
+
+    lowered = cleaned.lower()
+
+    # Map short labels to canonical forms first
+    short_label_map = {
+        "w": "Wake",
+        "wake": "Wake",
+        "awake": "Wake",
+        "n1": "Non-REM stage 1",
+        "n2": "Non-REM stage 2",
+        "n3": "Non-REM stage 3",
+        "n4": "Non-REM stage 3",  # Merge stage 4 into stage 3
+        "rem": "REM sleep",
+        "r": "REM sleep",
+        "mov": "Movement",
+        "mt": "Movement",
+        "movement": "Movement",
+    }
+
+    if lowered in short_label_map:
+        canonical = short_label_map[lowered]
+    # Normalize common variants and merge stage 4 into stage 3
+    elif "non-rem" in lowered or "nrem" in lowered:
+        lowered = lowered.replace("nrem", "non-rem")
+        lowered = lowered.replace("non rem", "non-rem")
+
+        # Map stage 4 -> stage 3
+        if "stage 4" in lowered:
+            canonical = "Non-REM stage 3"
+        elif "stage 3" in lowered:
+            canonical = "Non-REM stage 3"
+        elif "stage 2" in lowered:
+            canonical = "Non-REM stage 2"
+        elif "stage 1" in lowered:
+            canonical = "Non-REM stage 1"
+        else:
+            canonical = cleaned
+    elif "rem" in lowered and "sleep" in lowered:
+        canonical = "REM sleep"
+    else:
+        label_set = SUPPORTED_LABELS if SUPPORTED_LABELS else FALLBACK_LABELS
+        maybe = next((lab for lab in label_set if lab.lower() == lowered), "")
+        canonical = maybe if maybe else cleaned
+
+    label_set = SUPPORTED_LABELS if SUPPORTED_LABELS else FALLBACK_LABELS
+    is_supported = canonical in label_set
+    return canonical if canonical else cleaned, is_supported
+
+
+def extract_answer(text: str) -> str:
+    """Extract the final answer from text.
+
+    Handles formats like:
+    - "Answer: Wake" -> "Wake"
+    - "Answer: Non-REM stage 2" -> "Non-REM stage 2"
+    - "Answer: N2" -> "N2"
+    """
+    if text is None:
+        return ""
+    text = str(text)
+
+    if "Answer: " not in text:
+        return text.strip()
+
+    # Take the last "Answer: " and get what follows
+    answer = text.split("Answer: ")[-1].strip()
+
+    # Take only the first line (in case model continues generating)
+    answer = answer.split("\n")[0].strip()
+
+    # Remove any end-of-text tokens
+    answer = re.sub(r'<\|.*?\|>|<eos>$', '', answer).strip()
+    # Remove trailing punctuation
+    answer = re.sub(r'[\.,;:!?]+$', '', answer).strip()
+
+    return answer
+
+
+def calculate_f1_score(prediction: str, ground_truth: str) -> Dict[str, Any]:
+    """Calculate F1 score for single-label classification with supported labels."""
+    pred_canon, pred_supported = _canonicalize_label(prediction)
+    truth_canon, truth_supported = _canonicalize_label(ground_truth)
+
+    f1 = 1.0 if pred_canon == truth_canon else 0.0
+
+    return {
+        'f1_score': f1,
+        'precision': f1,
+        'recall': f1,
+        'prediction_normalized': pred_canon.lower().strip(),
+        'ground_truth_normalized': truth_canon.lower().strip(),
+        'prediction_supported': pred_supported,
+        'ground_truth_supported': truth_supported,
+    }
+
+
+def calculate_f1_stats(data_points: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Calculate both macro-F1 and average F1 (micro-F1) statistics."""
+    if not data_points:
+        return {}
+
+    f1_scores = [point.get("f1_score", 0) for point in data_points]
+    average_f1 = sum(f1_scores) / len(f1_scores) if f1_scores else 0
+
+    labels_to_use = SUPPORTED_LABELS if SUPPORTED_LABELS else FALLBACK_LABELS
+    supported_lower = {label.lower(): label for label in labels_to_use}
+    class_predictions = {lab.lower(): {"tp": 0, "fp": 0, "fn": 0} for lab in labels_to_use}
+
+    for point in data_points:
+        gt_class = point.get("ground_truth_normalized", "")
+        pred_class = point.get("prediction_normalized", "")
+        pred_supported = point.get("prediction_supported", False)
+
+        if gt_class not in class_predictions:
+            continue
+
+        if pred_class == gt_class:
+            class_predictions[gt_class]["tp"] += 1
+        else:
+            class_predictions[gt_class]["fn"] += 1
+            if pred_supported and pred_class in class_predictions:
+                class_predictions[pred_class]["fp"] += 1
+
+    class_f1_scores = {}
+    total_f1 = 0
+    valid_classes = 0
+
+    for class_name, counts in class_predictions.items():
+        tp, fp, fn = counts["tp"], counts["fp"], counts["fn"]
+
+        precision = tp / (tp + fp) if (tp + fp) > 0 else 0
+        recall = tp / (tp + fn) if (tp + fn) > 0 else 0
+        f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+
+        pretty_name = supported_lower.get(class_name, class_name)
+        class_f1_scores[pretty_name] = {
+            "f1": f1,
+            "precision": precision,
+            "recall": recall,
+            "tp": tp,
+            "fp": fp,
+            "fn": fn,
+        }
+
+        total_f1 += f1
+        valid_classes += 1
+
+    macro_f1 = total_f1 / valid_classes if valid_classes > 0 else 0
+
+    return {
+        "average_f1": average_f1,
+        "macro_f1": macro_f1,
+        "class_f1_scores": class_f1_scores,
+        "total_classes": valid_classes,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Evaluate sleep inference results from CSV")
+    parser.add_argument("csv_path", type=str, help="Path to inference results CSV")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Show per-sample details")
+    args = parser.parse_args()
+
+    global SUPPORTED_LABELS
+
+    # Load CSV
+    df = pd.read_csv(args.csv_path)
+    print(f"Loaded {len(df)} samples from {args.csv_path}\n")
+
+    # First pass: discover labels from ground truth
+    discovered_labels = set()
+    for _, row in df.iterrows():
+        gt_raw = extract_answer(str(row["target_answer"]))
+        gt_canon, _ = _canonicalize_label(gt_raw)
+        if gt_canon:
+            discovered_labels.add(gt_canon)
+
+    SUPPORTED_LABELS = list(discovered_labels)
+    print(f"Discovered {len(SUPPORTED_LABELS)} labels from ground truth:")
+    for label in sorted(SUPPORTED_LABELS):
+        print(f"  - {label}")
+    print()
+
+    # Second pass: evaluate each sample
+    data_points = []
+    for idx, row in df.iterrows():
+        gt_raw = extract_answer(str(row["target_answer"]))
+        pred_raw = extract_answer(str(row["generated_answer"]))
+
+        pred_canon, pred_supported = _canonicalize_label(pred_raw)
+        gt_canon, gt_supported = _canonicalize_label(gt_raw)
+
+        accuracy = (pred_canon == gt_canon) and gt_supported
+        f1_result = calculate_f1_score(pred_raw, gt_raw)
+
+        data_point = {
+            "accuracy": accuracy,
+            "f1_score": f1_result['f1_score'],
+            "precision": f1_result['precision'],
+            "recall": f1_result['recall'],
+            "prediction_normalized": f1_result['prediction_normalized'],
+            "ground_truth_normalized": f1_result['ground_truth_normalized'],
+            "prediction_supported": f1_result['prediction_supported'],
+            "ground_truth_supported": f1_result['ground_truth_supported'],
+        }
+        data_points.append(data_point)
+
+        if args.verbose:
+            status = "✓" if accuracy else "✗"
+            print(f"[{idx}] {status} GT: {gt_canon} | Pred: {pred_canon}")
+
+    # Calculate statistics
+    total = len(data_points)
+    correct = sum(1 for p in data_points if p.get("accuracy", False))
+    accuracy_pct = (correct / total) * 100 if total > 0 else 0
+
+    f1_stats = calculate_f1_stats(data_points)
+
+    # Print results
+    print("=" * 80)
+    print("EVALUATION RESULTS")
+    print("=" * 80)
+    print(f"Total samples: {total}")
+    print(f"Correct predictions: {correct}")
+    print(f"Accuracy: {accuracy_pct:.2f}%")
+    print(f"\nAverage F1 Score: {f1_stats.get('average_f1', 0):.4f}")
+    print(f"Macro-F1 Score: {f1_stats.get('macro_f1', 0):.4f}")
+
+    # Per-class statistics
+    class_f1_scores = f1_stats.get("class_f1_scores", {})
+    if class_f1_scores:
+        print(f"\nPer-Class Statistics:")
+        for class_name, scores in sorted(class_f1_scores.items()):
+            print(f"  {class_name}:")
+            print(f"    F1: {scores['f1']:.4f}, Precision: {scores['precision']:.4f}, Recall: {scores['recall']:.4f}")
+            print(f"    TP: {scores['tp']}, FP: {scores['fp']}, FN: {scores['fn']}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/evaluation/baseline/finetune_ecg_qa_plot.py b/evaluation/baseline/finetune_ecg_qa_plot.py
new file mode 100644
index 00000000..d25c7446
--- /dev/null
+++ b/evaluation/baseline/finetune_ecg_qa_plot.py
@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+#
+# Fine-tune Gemma on the ECG-QA CoT dataset with LoRA
+#
+
+import os
+import sys
+import argparse
+
+# Ensure project src/ is on sys.path so we can import time_series_datasets
+PROJECT_SRC = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "src"))
+if PROJECT_SRC not in sys.path:
+    sys.path.insert(0, PROJECT_SRC)
+
+# Also add project root so we can import sibling modules when running script directly.
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from time_series_datasets.ecg_qa.ECGQACoTQADataset import ECGQACoTQADataset
+
+# Prefer local import when running from evaluation/baseline, fall back to package path
+try:
+    from common_finetune_sft import run_sft  # when cwd is this folder or script path is used
+except ModuleNotFoundError:
+    from evaluation.baseline.common_finetune_sft import run_sft
+
+
+def _get_ecg_id_from_sample(sample: dict) -> int:
+    """Extract ECG ID from a sample dict."""
+    ecg_id = sample.get("ecg_id")
+    if ecg_id is None:
+        raise ValueError("Sample missing 'ecg_id' field")
+
+    if isinstance(ecg_id, list):
+        if len(ecg_id) == 0:
+            raise ValueError("Sample 'ecg_id' list is empty")
+        return ecg_id[0]
+
+    return ecg_id
+
+
+def _build_messages_from_sample(sample: dict, eos_token: str = "") -> dict:
+    """Build chat-style messages with lazy ECG ID reference (no image rendering upfront)."""
+    pre = (sample.get("pre_prompt") or "").strip()
+    post = (sample.get("post_prompt") or "").strip()
+    ans = (sample.get("answer") or "").strip()
+
+    if eos_token:
+        ans = ans + eos_token
+
+    # Store only the ECG ID - image will be rendered lazily in collate_fn
+    ecg_id = _get_ecg_id_from_sample(sample)
+
+    question = sample.get("question")
+    if question:
+        pre_text = f"{pre}\n\nQuestion: {question}" if pre else f"Question: {question}"
+    else:
+        pre_text = pre
+
+    user_text = "\n\n".join([p for p in [pre_text, post] if p])
+    messages = [
+        {
+            "role": "system",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "You are a helpful medical AI that analyzes ECG time series to answer cardiology questions.",
+                }
+            ],
+        },
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": user_text},
+                {"type": "image", "ecg_id": ecg_id},  # Lazy reference - no bytes yet
+            ],
+        },
+        {
+            "role": "assistant",
+            "content": [{"type": "text", "text": ans}],
+        },
+    ]
+    return {"messages": messages}
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Fine-tune Gemma on the ECG-QA CoT dataset with LoRA"
+    )
+    # SFT options
+    parser.add_argument("--output-dir", type=str, default="runs/gemma3-4b-pt-ecgqa-lora")
+    parser.add_argument("--llm-id", type=str, default="google/gemma-3-4b-pt")
+    parser.add_argument("--max-samples", type=int, default=1000, help="Number of samples to process in this run")
+    parser.add_argument("--exclude-comparison", action="store_true", help="Exclude comparison-type ECG-QA questions")
+    parser.add_argument("--preload-processed-data", action="store_true", help="Preload processed ECG data (faster, more RAM). Default off.")
+    parser.add_argument("--epochs", type=int, default=1)
+    parser.add_argument("--learning-rate", type=float, default=1e-4)
+    parser.add_argument("--per-device-train-batch-size", type=int, default=1)
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=16)
+    parser.add_argument("--max-seq-len", type=int, default=4096)
+
+    args = parser.parse_args()
+
+    # Load processor to get EOS token
+    from transformers import AutoProcessor
+    processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
+    eos_token = processor.tokenizer.eos_token
+
+    # Load dataset
+    ds = ECGQACoTQADataset(
+        split="train",
+        EOS_TOKEN="",
+        max_samples=args.max_samples,
+        exclude_comparison=args.exclude_comparison,
+        preload_processed_data=args.preload_processed_data,
+    )
+
+    print(f"Processing {len(ds)} samples (lazy image loading - images rendered on-demand)")
+
+    train_examples = [_build_messages_from_sample(ds[i], eos_token=eos_token) for i in range(len(ds))]
+
+    # Run SFT training
+    run_sft(
+        train_examples,
+        output_dir=args.output_dir,
+        llm_id=args.llm_id,
+        epochs=args.epochs,
+        learning_rate=args.learning_rate,
+        per_device_train_batch_size=args.per_device_train_batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        max_seq_len=args.max_seq_len,
+        save_steps=500,
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/evaluation/baseline/finetune_har_plot.py b/evaluation/baseline/finetune_har_plot.py
new file mode 100644
index 00000000..34e07c28
--- /dev/null
+++ b/evaluation/baseline/finetune_har_plot.py
@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""Fine-tune Gemma on HAR (Human Activity Recognition) dataset with LoRA."""
+
+import os
+import sys
+import argparse
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
+from PIL import Image
+import io
+
+PROJECT_SRC = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "src"))
+if PROJECT_SRC not in sys.path:
+    sys.path.insert(0, PROJECT_SRC)
+
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from time_series_datasets.har_cot.HARCoTQADataset import HARCoTQADataset
+
+try:
+    from common_finetune_sft import run_sft
+except ModuleNotFoundError:
+    from evaluation.baseline.common_finetune_sft import run_sft
+
+
+def _time_series_to_pil(time_series) -> Image.Image:
+    """Render a 1D or 2D time series array to a PIL RGB image."""
+    if isinstance(time_series, np.ndarray):
+        if time_series.ndim == 1:
+            ts_list = [time_series]
+        elif time_series.ndim == 2:
+            ts_list = [time_series[i] for i in range(time_series.shape[0])]
+        else:
+            raise ValueError(f"Unsupported ndarray shape: {time_series.shape}")
+    else:
+        ts_list = list(time_series)
+        if len(ts_list) > 0 and not hasattr(ts_list[0], "__len__"):
+            ts_list = [ts_list]
+
+    n = len(ts_list)
+    fig, axes = plt.subplots(n, 1, figsize=(10, 2.5 * n), dpi=100, sharex=True)
+    if n == 1:
+        axes = [axes]
+    axis_labels = ["X-axis", "Y-axis", "Z-axis"]
+    for i, s in enumerate(ts_list):
+        s = np.asarray(s)
+        axes[i].plot(s, marker="o", linestyle="-", markersize=0)
+        axes[i].set_ylabel(axis_labels[i] if i < len(axis_labels) else f"Axis {i+1}")
+        axes[i].grid(True, alpha=0.3)
+    axes[-1].set_xlabel("Time (samples)")
+    plt.tight_layout(pad=0.1)
+
+    canvas = FigureCanvas(fig)
+    buf = io.BytesIO()
+    canvas.print_png(buf)
+    plt.close(fig)
+    buf.seek(0)
+    img = Image.open(buf).convert("RGB")
+    return img
+
+
+def _build_messages_from_sample(sample: dict, eos_token: str = "") -> dict:
+    """Build chat-style messages with accelerometer plot for training."""
+    pre = (sample.get("pre_prompt") or "").strip()
+    post = (sample.get("post_prompt") or "").strip()
+    ans = (sample.get("answer") or "").strip()
+
+    if eos_token:
+        ans = ans + eos_token
+
+    x_axis = sample.get("x_axis", [])
+    y_axis = sample.get("y_axis", [])
+    z_axis = sample.get("z_axis", [])
+
+    ts = np.array([x_axis, y_axis, z_axis])
+    img = _time_series_to_pil(ts)
+
+    user_text = "\n\n".join([p for p in [pre, post] if p])
+    messages = [
+        {
+            "role": "system",
+            "content": [{"type": "text", "text": "You are a helpful AI that analyzes accelerometer data for human activity recognition."}],
+        },
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": user_text},
+                {"type": "image", "image": img},
+            ],
+        },
+        {
+            "role": "assistant",
+            "content": [{"type": "text", "text": ans}],
+        },
+    ]
+    return {"messages": messages}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fine-tune Gemma on HAR dataset with LoRA")
+    parser.add_argument("--output-dir", type=str, default="runs/gemma3-4b-pt-har-lora")
+    parser.add_argument("--llm-id", type=str, default="google/gemma-3-4b-pt")
+    parser.add_argument("--max-samples", type=int, default=1000)
+    parser.add_argument("--epochs", type=int, default=1)
+    parser.add_argument("--learning-rate", type=float, default=1e-4)
+    parser.add_argument("--per-device-train-batch-size", type=int, default=1)
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=16)
+    parser.add_argument("--max-seq-len", type=int, default=4096)
+    args = parser.parse_args()
+
+    from transformers import AutoProcessor
+    processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
+    eos_token = processor.tokenizer.eos_token
+
+    ds = HARCoTQADataset(split="train", EOS_TOKEN="")
+    n = len(ds) if args.max_samples is None else min(args.max_samples, len(ds))
+    train_examples = [_build_messages_from_sample(ds[i], eos_token=eos_token) for i in range(n)]
+
+    run_sft(
+        train_examples,
+        output_dir=args.output_dir,
+        llm_id=args.llm_id,
+        epochs=args.epochs,
+        learning_rate=args.learning_rate,
+        per_device_train_batch_size=args.per_device_train_batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        max_seq_len=args.max_seq_len,
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/evaluation/baseline/finetune_sleep_plot.py b/evaluation/baseline/finetune_sleep_plot.py
new file mode 100644
index 00000000..3e5e1020
--- /dev/null
+++ b/evaluation/baseline/finetune_sleep_plot.py
@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""Fine-tune Gemma on SleepEDF dataset with LoRA."""
+
+import os
+import sys
+import argparse
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
+from PIL import Image
+import io
+
+PROJECT_SRC = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "src"))
+if PROJECT_SRC not in sys.path:
+    sys.path.insert(0, PROJECT_SRC)
+
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from time_series_datasets.sleep.SleepEDFCoTQADataset import SleepEDFCoTQADataset
+
+try:
+    from common_finetune_sft import run_sft
+except ModuleNotFoundError:
+    from evaluation.baseline.common_finetune_sft import run_sft
+
+
+def _time_series_to_pil(time_series) -> Image.Image:
+    """Render the first channel (EEG) of a time series array to a PIL RGB image."""
+    if isinstance(time_series, np.ndarray):
+        if time_series.ndim == 1:
+            eeg = time_series
+        elif time_series.ndim == 2:
+            eeg = time_series[0]
+        else:
+            raise ValueError(f"Unsupported ndarray shape: {time_series.shape}")
+    else:
+        ts_list = list(time_series)
+        if len(ts_list) > 0 and hasattr(ts_list[0], "__len__"):
+            eeg = np.asarray(ts_list[0])
+        else:
+            eeg = np.asarray(ts_list)
+
+    fig, ax = plt.subplots(figsize=(10, 2.5), dpi=100)
+    ax.plot(eeg, marker="o", linestyle="-", markersize=0)
+    ax.set_ylabel("EEG")
+    ax.set_xlabel("Time (samples)")
+    ax.grid(True, alpha=0.3)
+    plt.tight_layout(pad=0.1)
+
+    canvas = FigureCanvas(fig)
+    buf = io.BytesIO()
+    canvas.print_png(buf)
+    plt.close(fig)
+    buf.seek(0)
+    img = Image.open(buf).convert("RGB")
+    return img
+
+
+def _build_messages_from_sample(sample: dict, eos_token: str = "") -> dict:
+    """Build chat-style messages with EEG plot for training."""
+    pre = (sample.get("pre_prompt") or "").strip()
+    post = (sample.get("post_prompt") or "").strip()
+    ans = (sample.get("answer") or "").strip()
+
+    if eos_token:
+        ans = ans + eos_token
+
+    ts = sample.get("original_data", sample.get("time_series", None))
+    img = _time_series_to_pil(ts)
+
+    user_text = "\n\n".join([p for p in [pre, post] if p])
+    messages = [
+        {
+            "role": "system",
+            "content": [{"type": "text", "text": "You are a helpful medical AI that analyzes sleep EEG."}],
+        },
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": user_text},
+                {"type": "image", "image": img},
+            ],
+        },
+        {
+            "role": "assistant",
+            "content": [{"type": "text", "text": ans}],
+        },
+    ]
+    return {"messages": messages}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fine-tune Gemma on SleepEDF dataset with LoRA")
+    parser.add_argument("--output-dir", type=str, default="runs/gemma3-4b-pt-sleep-lora")
+    parser.add_argument("--llm-id", type=str, default="google/gemma-3-4b-pt")
+    parser.add_argument("--max-samples", type=int, default=1000)
+    parser.add_argument("--epochs", type=int, default=1)
+    parser.add_argument("--learning-rate", type=float, default=1e-4)
+    parser.add_argument("--per-device-train-batch-size", type=int, default=1)
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=16)
+    parser.add_argument("--max-seq-len", type=int, default=4096)
+    args = parser.parse_args()
+
+    from transformers import AutoProcessor
+    processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
+    eos_token = processor.tokenizer.eos_token
+
+    ds = SleepEDFCoTQADataset(split="train", EOS_TOKEN="")
+    n = len(ds) if args.max_samples is None else min(args.max_samples, len(ds))
+    train_examples = [_build_messages_from_sample(ds[i], eos_token=eos_token) for i in range(n)]
+
+    run_sft(
+        train_examples,
+        output_dir=args.output_dir,
+        llm_id=args.llm_id,
+        epochs=args.epochs,
+        learning_rate=args.learning_rate,
+        per_device_train_batch_size=args.per_device_train_batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        max_seq_len=args.max_seq_len,
+    )
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/evaluation/baseline/finetune_tsqa_plot.py b/evaluation/baseline/finetune_tsqa_plot.py
new file mode 100644
index 00000000..3a77ccef
--- /dev/null
+++ b/evaluation/baseline/finetune_tsqa_plot.py
@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Fine-tune Gemma on TSQA dataset with LoRA."""
+
+import os
+import sys
+import argparse
+import json
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
+from PIL import Image
+import io
+
+PROJECT_SRC = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "src"))
+if PROJECT_SRC not in sys.path:
+    sys.path.insert(0, PROJECT_SRC)
+
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from time_series_datasets.TSQADataset import TSQADataset
+
+try:
+    from common_finetune_sft import run_sft
+except ModuleNotFoundError:
+    from evaluation.baseline.common_finetune_sft import run_sft
+
+
+def _time_series_to_pil(time_series) -> Image.Image:
+    """Render a 1D time series array to a PIL RGB image."""
+    if isinstance(time_series, np.ndarray):
+        if time_series.ndim > 1:
+            time_series = time_series[0]
+    else:
+        time_series = np.array(time_series)
+        if len(time_series.shape) > 1:
+            time_series = time_series[0]
+
+    fig, ax = plt.subplots(figsize=(10, 2.5), dpi=100)
+    ax.plot(time_series, marker="o", linestyle="-", markersize=0)
+    ax.set_ylabel("Value")
+    ax.set_xlabel("Time")
+    ax.grid(True, alpha=0.3)
+    plt.tight_layout(pad=0.1)
+
+    canvas = FigureCanvas(fig)
+    buf = io.BytesIO()
+    canvas.print_png(buf)
+    plt.close(fig)
+    buf.seek(0)
+    img = Image.open(buf).convert("RGB")
+    return img
+
+
+def _build_messages_from_sample(sample: dict, eos_token: str = "") -> dict:
+    """Build chat-style messages with time series plot for training."""
+    pre = (sample.get("pre_prompt") or "").strip()
+    post = (sample.get("post_prompt") or "").strip()
+    ans = (sample.get("answer") or "").strip()
+
+    if eos_token:
+        ans = ans + eos_token
+
+    time_series = sample.get("time_series", [])
+    if not time_series and "Series" in sample:
+        time_series = json.loads(sample["Series"])
+
+    img = _time_series_to_pil(time_series)
+
+    messages = [
+        {
+            "role": "system",
+            "content": [{"type": "text", "text": "You are a helpful AI that analyzes time series data to answer questions."}],
+        },
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": f"{pre}\n\n{post}"},
+                {"type": "image", "image": img},
+            ],
+        },
+        {
+            "role": "assistant",
+            "content": [{"type": "text", "text": ans}],
+        },
+    ]
+    return {"messages": messages}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fine-tune Gemma on TSQA dataset with LoRA")
+    parser.add_argument("--output-dir", type=str, default="runs/gemma3-4b-pt-tsqa-lora")
+    parser.add_argument("--llm-id", type=str, default="google/gemma-3-4b-pt")
+    parser.add_argument("--max-samples", type=int, default=1000)
+    parser.add_argument("--epochs", type=int, default=1)
+    parser.add_argument("--learning-rate", type=float, default=1e-4)
+    parser.add_argument("--per-device-train-batch-size", type=int, default=1)
+    parser.add_argument("--gradient-accumulation-steps", type=int, default=16)
+    parser.add_argument("--max-seq-len", type=int, default=4096)
+    args = parser.parse_args()
+
+    from transformers import AutoProcessor
+    processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
+    eos_token = processor.tokenizer.eos_token
+
+    ds = TSQADataset(split="train", EOS_TOKEN="")
+    n = len(ds) if args.max_samples is None else min(args.max_samples, len(ds))
+    train_examples = [_build_messages_from_sample(ds[i], eos_token=eos_token) for i in range(n)]
+
+    run_sft(
+        train_examples,
+        output_dir=args.output_dir,
+        llm_id=args.llm_id,
+        epochs=args.epochs,
+        learning_rate=args.learning_rate,
+        per_device_train_batch_size=args.per_device_train_batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        max_seq_len=args.max_seq_len,
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/evaluation/baseline/inference_ecg_qa_lora.py b/evaluation/baseline/inference_ecg_qa_lora.py
new file mode 100644
index 00000000..3e991656
--- /dev/null
+++ b/evaluation/baseline/inference_ecg_qa_lora.py
@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""
+Inference script for the fine-tuned LoRA model on ECG-QA CoT data.
+Loads the base model + LoRA adapters and runs inference on new examples.
+Uses doctor-style ECG plots matching the finetuning format.
+"""
+import os
+import sys
+import torch
+from transformers import AutoModelForImageTextToText, AutoProcessor
+from peft import PeftModel
+import csv
+from tqdm import tqdm
+
+# Add project paths
+PROJECT_SRC = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "src"))
+if PROJECT_SRC not in sys.path:
+    sys.path.insert(0, PROJECT_SRC)
+
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from time_series_datasets.ecg_qa.ECGQACoTQADataset import ECGQACoTQADataset
+
+# Import ECG plotting functions from common_finetune_sft
+try:
+    from common_finetune_sft import _load_ecg_data, _ecg_to_image
+except ModuleNotFoundError:
+    from evaluation.baseline.common_finetune_sft import _load_ecg_data, _ecg_to_image
+
+
+def load_model_and_processor(base_model_id: str, lora_adapter_path: str = None):
+    """Load base model with optional LoRA adapters."""
+    print(f"Loading base model: {base_model_id}")
+
+    model = AutoModelForImageTextToText.from_pretrained(
+        base_model_id,
+        attn_implementation="flash_attention_2",
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        low_cpu_mem_usage=True,
+    )
+
+    if lora_adapter_path:
+        print(f"Loading LoRA adapters from: {lora_adapter_path}")
+        model = PeftModel.from_pretrained(model, lora_adapter_path)
+        processor = AutoProcessor.from_pretrained(lora_adapter_path)
+    else:
+        print("No LoRA adapters specified - using base model only")
+        processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
+
+    model.eval()
+    print("Model and processor loaded successfully!")
+    return model, processor
+
+
+def run_inference(model, processor, messages, max_new_tokens=512, temperature=0.7):
+    """Run inference on a single example and return generated text."""
+    images = []
+    for msg in messages:
+        content = msg.get("content", [])
+        if not isinstance(content, list):
+            content = [content]
+        for element in content:
+            if isinstance(element, dict) and ("image" in element or element.get("type") == "image"):
+                image = element.get("image", element)
+                if image is not None and hasattr(image, "convert"):
+                    images.append(image.convert("RGB"))
+
+    text = processor.apply_chat_template(
+        messages, add_generation_prompt=True, tokenize=False
+    )
+
+    inputs = processor(
+        text=text,
+        images=images if images else None,
+        return_tensors="pt",
+        padding=True
+    )
+    inputs = {k: v.to(model.device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            do_sample=True if temperature > 0 else False,
+            pad_token_id=processor.tokenizer.pad_token_id,
+            eos_token_id=processor.tokenizer.eos_token_id,
+        )
+
+    generated_text = processor.decode(outputs[0], skip_special_tokens=True)
+    prompt_text = processor.decode(inputs["input_ids"][0], skip_special_tokens=True)
+    if generated_text.startswith(prompt_text):
+        generated_text = generated_text[len(prompt_text):].strip()
+
+    return generated_text
+
+
+def _get_ecg_id_from_sample(sample: dict) -> int:
+    """Extract ECG ID from a sample dict."""
+    ecg_id = sample.get("ecg_id")
+    if ecg_id is None:
+        raise ValueError("Sample missing 'ecg_id' field")
+    if isinstance(ecg_id, list):
+        if len(ecg_id) == 0:
+            raise ValueError("Sample 'ecg_id' list is empty")
+        return ecg_id[0]
+    return ecg_id
+
+
+def _build_messages_from_sample_for_inference(sample: dict) -> tuple:
+    """Build chat messages with ECG plot. Returns (messages, user_text)."""
+    pre = (sample.get("pre_prompt") or "").strip()
+    post = (sample.get("post_prompt") or "").strip()
+    question = sample.get("question")
+
+    ecg_id = _get_ecg_id_from_sample(sample)
+    ecg_data = _load_ecg_data(ecg_id)
+    img = _ecg_to_image(ecg_data)
+
+    if question:
+        pre_text = f"{pre}\n\nQuestion: {question}" if pre else f"Question: {question}"
+    else:
+        pre_text = pre
+
+    user_text = "\n\n".join([p for p in [pre_text, post] if p])
+
+    messages = [
+        {
+            "role": "system",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "You are a helpful medical AI that analyzes ECG time series to answer cardiology questions.",
+                }
+            ],
+        },
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": user_text},
+                {"type": "image", "image": img},
+            ],
+        },
+    ]
+    return messages, user_text
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Run inference with LoRA model on ECG-QA CoT data")
+    parser.add_argument("--base-model", type=str, default="google/gemma-3-4b-pt")
+    parser.add_argument("--lora-path", type=str, default="runs/gemma3-4b-pt-ecgqa-lora",
+                        help="Path to LoRA adapters. Set to 'none' or empty to use base model only.")
+    parser.add_argument("--max-new-tokens", type=int, default=400)
+    parser.add_argument("--temperature", type=float, default=0.0)
+    parser.add_argument("--split", type=str, default="test", choices=["train", "test", "validation"])
+    parser.add_argument("--output-csv", type=str, default="inference_ecg_qa_results.csv",
+                        help="Path to save results CSV file")
+    parser.add_argument("--max-samples", type=int, default=None,
+                        help="Maximum number of samples to process (default: all)")
+    parser.add_argument("--exclude-comparison", action="store_true",
+                        help="Exclude comparison-type ECG-QA questions")
+    args = parser.parse_args()
+
+    base_model_id = args.base_model
+    lora_adapter_path = args.lora_path if args.lora_path and args.lora_path.lower() != 'none' else None
+
+    model, processor = load_model_and_processor(base_model_id, lora_adapter_path)
+
+    print(f"\nLoading ECG-QA {args.split} split...")
+    ds = ECGQACoTQADataset(
+        split=args.split,
+        EOS_TOKEN="",
+        max_samples=args.max_samples,
+        exclude_comparison=args.exclude_comparison,
+    )
+    print(f"Dataset size: {len(ds)}")
+
+    num_samples = len(ds)
+    print(f"Processing {num_samples} samples...\n")
+
+    results = []
+    fieldnames = ["sample_idx", "input_text", "target_answer", "generated_answer", "template_id"]
+    print(f"Initializing output CSV with header at: {args.output_csv}")
+    with open(args.output_csv, 'w', newline='', encoding='utf-8') as csvfile:
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+
+    for idx in tqdm(range(num_samples), desc="Running inference"):
+        try:
+            sample = ds[idx]
+
+            ground_truth = sample.get("answer", "")
+            template_id = sample.get("template_id") or sample.get("cot_template_id", "")
+            messages, user_text = _build_messages_from_sample_for_inference(sample)
+            response = run_inference(model, processor, messages, max_new_tokens=args.max_new_tokens, temperature=args.temperature)
+
+            result = {
+                "sample_idx": idx,
+                "input_text": user_text,
+                "target_answer": ground_truth,
+                "generated_answer": response,
+                "template_id": template_id,
+            }
+            results.append(result)
+
+            if idx < 5:
+                print("\n" + "="*80)
+                print(f"SAMPLE {idx} from {args.split} split")
+                print("="*80)
+                print(f"\nQUESTION:\n{user_text[:500]}...")
+                print(f"\nGROUND TRUTH:\n{ground_truth}")
+                print(f"\nMODEL RESPONSE:\n{response}")
+                print("="*80)
+
+            if (idx + 1) % 100 == 0:
+                with open(args.output_csv, 'a', newline='', encoding='utf-8') as csvfile:
+                    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                    for r in results:
+                        writer.writerow(r)
+                print(f"Flushed {len(results)} results to {args.output_csv} at idx={idx}")
+                results = []
+
+        except Exception as e:
+            print(f"Error on sample {idx}: {e}")
+            continue
+
+    if results:
+        with open(args.output_csv, 'a', newline='', encoding='utf-8') as csvfile:
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            for r in results:
+                writer.writerow(r)
+        print(f"Final flush: wrote remaining {len(results)} results to {args.output_csv}")
+
+    print(f"Completed writing all results to {args.output_csv}")
+    print("\n" + "="*80)
+    print("ECG-QA inference completed successfully!")
+    print("="*80)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/evaluation/baseline/inference_har_lora.py b/evaluation/baseline/inference_har_lora.py
new file mode 100644
index 00000000..780cda89
--- /dev/null
+++ b/evaluation/baseline/inference_har_lora.py
@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""
+Inference script for the fine-tuned LoRA model on HAR (Human Activity Recognition) CoT data.
+Loads the base model + LoRA adapters and runs inference on new examples.
+"""
+import os
+import sys
+import torch
+from transformers import AutoModelForImageTextToText, AutoProcessor
+from peft import PeftModel
+import numpy as np
+import csv
+from tqdm import tqdm
+
+# Add project paths
+PROJECT_SRC = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "src"))
+if PROJECT_SRC not in sys.path:
+    sys.path.insert(0, PROJECT_SRC)
+
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from time_series_datasets.har_cot.HARCoTQADataset import HARCoTQADataset
+
+# Import the helper function from finetune_har_plot
+try:
+    from finetune_har_plot import _time_series_to_pil
+except ModuleNotFoundError:
+    from evaluation.baseline.finetune_har_plot import _time_series_to_pil
+
+
+def load_model_and_processor(base_model_id: str, lora_adapter_path: str = None):
+    """Load base model with optional LoRA adapters."""
+    print(f"Loading base model: {base_model_id}")
+
+    model = AutoModelForImageTextToText.from_pretrained(
+        base_model_id,
+        attn_implementation="sdpa",
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        low_cpu_mem_usage=True,
+    )
+
+    if lora_adapter_path:
+        print(f"Loading LoRA adapters from: {lora_adapter_path}")
+        model = PeftModel.from_pretrained(model, lora_adapter_path)
+        processor = AutoProcessor.from_pretrained(lora_adapter_path)
+    else:
+        print("No LoRA adapters specified - using base model only")
+        processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
+
+    model.eval()
+    print("Model and processor loaded successfully!")
+    return model, processor
+
+
+def run_inference(model, processor, messages, max_new_tokens=512, temperature=0.7):
+    """Run inference on a single example and return generated text."""
+    images = []
+    for msg in messages:
+        content = msg.get("content", [])
+        if not isinstance(content, list):
+            content = [content]
+        for element in content:
+            if isinstance(element, dict) and ("image" in element or element.get("type") == "image"):
+                image = element.get("image", element)
+                if image is not None and hasattr(image, "convert"):
+                    images.append(image.convert("RGB"))
+
+    text = processor.apply_chat_template(
+        messages, add_generation_prompt=True, tokenize=False
+    )
+
+    inputs = processor(
+        text=text,
+        images=images if images else None,
+        return_tensors="pt",
+        padding=True
+    )
+    inputs = {k: v.to(model.device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            do_sample=True if temperature > 0 else False,
+            pad_token_id=processor.tokenizer.pad_token_id,
+            eos_token_id=processor.tokenizer.eos_token_id,
+        )
+
+    generated_text = processor.decode(outputs[0], skip_special_tokens=True)
+    prompt_text = processor.decode(inputs["input_ids"][0], skip_special_tokens=True)
+    if generated_text.startswith(prompt_text):
+        generated_text = generated_text[len(prompt_text):].strip()
+
+    return generated_text
+
+
+def _build_messages_from_sample_for_inference(sample: dict) -> tuple:
+    """Build chat messages with accelerometer plot. Returns (messages, user_text)."""
+    pre = (sample.get("pre_prompt") or "").strip()
+    post = (sample.get("post_prompt") or "").strip()
+
+    x_axis = sample.get("x_axis", [])
+    y_axis = sample.get("y_axis", [])
+    z_axis = sample.get("z_axis", [])
+
+    ts = np.array([x_axis, y_axis, z_axis])
+    img = _time_series_to_pil(ts)
+
+    user_text = "\n\n".join([p for p in [pre, post] if p])
+
+    messages = [
+        {
+            "role": "system",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "You are a helpful AI that analyzes accelerometer data for human activity recognition.",
+                }
+            ],
+        },
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": user_text},
+                {"type": "image", "image": img},
+            ],
+        },
+    ]
+    return messages, user_text
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Run inference with LoRA model on HAR CoT data")
+    parser.add_argument("--base-model", type=str, default="google/gemma-3-4b-pt")
+    parser.add_argument("--lora-path", type=str, default="runs/gemma3-4b-pt-har-lora",
+                        help="Path to LoRA adapters. Set to 'none' or empty to use base model only.")
+    parser.add_argument("--max-new-tokens", type=int, default=256)
+    parser.add_argument("--temperature", type=float, default=0.7)
+    parser.add_argument("--split", type=str, default="test", choices=["train", "test", "validation"])
+    parser.add_argument("--output-csv", type=str, default="inference_har_results.csv",
+                        help="Path to save results CSV file")
+    parser.add_argument("--max-samples", type=int, default=None,
+                        help="Maximum number of samples to process (default: all)")
+    args = parser.parse_args()
+
+    base_model_id = args.base_model
+    lora_adapter_path = args.lora_path if args.lora_path and args.lora_path.lower() != 'none' else None
+
+    model, processor = load_model_and_processor(base_model_id, lora_adapter_path)
+
+    print(f"\nLoading HAR {args.split} split...")
+    ds = HARCoTQADataset(split=args.split, EOS_TOKEN="")
+    print(f"Dataset size: {len(ds)}")
+
+    num_samples = len(ds) if args.max_samples is None else min(args.max_samples, len(ds))
+    print(f"Processing {num_samples} samples...\n")
+
+    results = []
+    fieldnames = ["sample_idx", "input_text", "target_answer", "generated_answer"]
+    print(f"Initializing output CSV with header at: {args.output_csv}")
+    with open(args.output_csv, 'w', newline='', encoding='utf-8') as csvfile:
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+
+    for idx in tqdm(range(num_samples), desc="Running inference"):
+        sample = ds[idx]
+
+        ground_truth = sample.get("label", "Unknown")
+        messages, user_text = _build_messages_from_sample_for_inference(sample)
+        response = run_inference(model, processor, messages, max_new_tokens=args.max_new_tokens, temperature=args.temperature)
+
+        result = {
+            "sample_idx": idx,
+            "input_text": user_text,
+            "target_answer": ground_truth,
+            "generated_answer": response,
+        }
+        results.append(result)
+
+        if idx < 5:
+            print("\n" + "="*80)
+            print(f"SAMPLE {idx} from {args.split} split")
+            print("="*80)
+            print(f"\nQUESTION:\n{user_text}")
+            print(f"\nGROUND TRUTH LABEL:\n{ground_truth}")
+            print(f"\nMODEL RESPONSE:\n{response}")
+            print("="*80)
+
+        if idx % 1000 == 0:
+            with open(args.output_csv, 'a', newline='', encoding='utf-8') as csvfile:
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                for r in results:
+                    writer.writerow(r)
+            print(f"Flushed {len(results)} results to {args.output_csv} at idx={idx}")
+            results = []
+
+    if results:
+        with open(args.output_csv, 'a', newline='', encoding='utf-8') as csvfile:
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            for r in results:
+                writer.writerow(r)
+        print(f"Final flush: wrote remaining {len(results)} results to {args.output_csv}")
+    
+    print(f"✓ Completed writing all results to {args.output_csv}")
+    print("\n" + "="*80)
+    print("HAR inference completed successfully!")
+    print("="*80)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/evaluation/baseline/inference_sleep_lora.py b/evaluation/baseline/inference_sleep_lora.py
new file mode 100644
index 00000000..2720a1b5
--- /dev/null
+++ b/evaluation/baseline/inference_sleep_lora.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""Inference script for fine-tuned LoRA model on SleepEDF data."""
+
+import os
+import sys
+import argparse
+import torch
+from transformers import AutoModelForImageTextToText, AutoProcessor
+from peft import PeftModel
+import csv
+from tqdm import tqdm
+
+PROJECT_SRC = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "src"))
+if PROJECT_SRC not in sys.path:
+    sys.path.insert(0, PROJECT_SRC)
+
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from time_series_datasets.sleep.SleepEDFCoTQADataset import SleepEDFCoTQADataset
+
+try:
+    from finetune_sleep_plot import _time_series_to_pil
+except ModuleNotFoundError:
+    from evaluation.baseline.finetune_sleep_plot import _time_series_to_pil
+
+
+def load_model_and_processor(base_model_id: str, lora_adapter_path: str = None):
+    """Load base model with optional LoRA adapters."""
+    print(f"Loading base model: {base_model_id}")
+
+    model = AutoModelForImageTextToText.from_pretrained(
+        base_model_id,
+        attn_implementation="flash_attention_2",
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        low_cpu_mem_usage=True,
+    )
+
+    if lora_adapter_path:
+        print(f"Loading LoRA adapters from: {lora_adapter_path}")
+        model = PeftModel.from_pretrained(model, lora_adapter_path)
+        processor = AutoProcessor.from_pretrained(lora_adapter_path)
+    else:
+        print("No LoRA adapters specified - using base model only")
+        processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
+
+    model.eval()
+    print("Model and processor loaded successfully!")
+    return model, processor
+
+
+def run_inference(model, processor, messages, max_new_tokens=512, temperature=0.7):
+    """Run inference on a single example and return generated text."""
+    images = []
+    for msg in messages:
+        content = msg.get("content", [])
+        if not isinstance(content, list):
+            content = [content]
+        for element in content:
+            if isinstance(element, dict) and ("image" in element or element.get("type") == "image"):
+                image = element.get("image", element)
+                if image is not None and hasattr(image, "convert"):
+                    images.append(image.convert("RGB"))
+
+    text = processor.apply_chat_template(
+        messages, add_generation_prompt=True, tokenize=False
+    )
+
+    inputs = processor(
+        text=text,
+        images=images if images else None,
+        return_tensors="pt",
+        padding=True
+    )
+    inputs = {k: v.to(model.device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            do_sample=True if temperature > 0 else False,
+            pad_token_id=processor.tokenizer.pad_token_id,
+            eos_token_id=processor.tokenizer.eos_token_id,
+        )
+
+    generated_text = processor.decode(outputs[0], skip_special_tokens=True)
+    prompt_text = processor.decode(inputs["input_ids"][0], skip_special_tokens=True)
+    if generated_text.startswith(prompt_text):
+        generated_text = generated_text[len(prompt_text):].strip()
+
+    return generated_text
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run inference with LoRA model on SleepEDF data")
+    parser.add_argument("--base-model", type=str, default="google/gemma-3-4b-pt")
+    parser.add_argument("--lora-path", type=str, default="runs/gemma3-4b-pt-sleep-lora",
+                        help="Path to LoRA adapters. Set to 'none' or empty to use base model only.")
+    parser.add_argument("--max-new-tokens", type=int, default=256)
+    parser.add_argument("--temperature", type=float, default=0.7)
+    parser.add_argument("--split", type=str, default="test", choices=["train", "test", "validation"])
+    parser.add_argument("--output-csv", type=str, default="inference_results.csv",
+                        help="Path to save results CSV file")
+    parser.add_argument("--max-samples", type=int, default=None,
+                        help="Maximum number of samples to process (default: all)")
+    args = parser.parse_args()
+
+    base_model_id = args.base_model
+    lora_adapter_path = args.lora_path if args.lora_path and args.lora_path.lower() != 'none' else None
+
+    model, processor = load_model_and_processor(base_model_id, lora_adapter_path)
+
+    print(f"\nLoading SleepEDF {args.split} split...")
+    ds = SleepEDFCoTQADataset(split=args.split, EOS_TOKEN="")
+    print(f"Dataset size: {len(ds)}")
+
+    num_samples = len(ds) if args.max_samples is None else min(args.max_samples, len(ds))
+    print(f"Processing {num_samples} samples...\n")
+
+    results = []
+
+    for idx in tqdm(range(num_samples), desc="Running inference"):
+        sample = ds[idx]
+
+        pre_prompt = (sample.get("pre_prompt") or "").strip()
+        post_prompt = (sample.get("post_prompt") or "").strip()
+        ground_truth = sample.get("label", "Unknown")
+
+        ts = sample.get("original_data", sample.get("time_series", None))
+        sleep_image = _time_series_to_pil(ts)
+
+        user_text = "\n\n".join([pre_prompt, post_prompt])
+
+        messages = [
+            {
+                "role": "system",
+                "content": [{"type": "text", "text": "You are a helpful medical AI that analyzes sleep EEG."}],
+            },
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": user_text},
+                    {"type": "image", "image": sleep_image},
+                ]
+            }
+        ]
+
+        response = run_inference(model, processor, messages, max_new_tokens=args.max_new_tokens, temperature=args.temperature)
+
+        result = {
+            "sample_idx": idx,
+            "input_text": user_text,
+            "target_answer": ground_truth,
+            "generated_answer": response,
+        }
+        results.append(result)
+
+        if idx < 5:
+            print("\n" + "="*80)
+            print(f"SAMPLE {idx} from {args.split} split")
+            print("="*80)
+            print(f"\nGround Truth Label: {ground_truth}")
+            print(f"\nQUESTION:\n{user_text}")
+            print(f"\nGT REASONING:\n{sample.get('answer', '')}")
+            print(f"\nMODEL RESPONSE:\n{response}")
+            print("="*80)
+
+    print(f"\n\nSaving results to {args.output_csv}...")
+    with open(args.output_csv, 'w', newline='', encoding='utf-8') as csvfile:
+        fieldnames = ["sample_idx", "input_text", "target_answer", "generated_answer"]
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+        for result in results:
+            writer.writerow(result)
+
+    print(f"Saved {len(results)} results to {args.output_csv}")
+    print("\n" + "="*80)
+    print("Inference completed successfully!")
+    print("="*80)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/evaluation/baseline/inference_tsqa_lora.py b/evaluation/baseline/inference_tsqa_lora.py
new file mode 100644
index 00000000..a96e97ac
--- /dev/null
+++ b/evaluation/baseline/inference_tsqa_lora.py
@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Inference script for fine-tuned LoRA model on TSQA data."""
+
+import os
+import sys
+import argparse
+import json
+import torch
+from transformers import AutoModelForImageTextToText, AutoProcessor
+from peft import PeftModel
+import csv
+from tqdm import tqdm
+
+PROJECT_SRC = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "src"))
+if PROJECT_SRC not in sys.path:
+    sys.path.insert(0, PROJECT_SRC)
+
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from time_series_datasets.TSQADataset import TSQADataset
+
+try:
+    from finetune_tsqa_plot import _time_series_to_pil
+except ModuleNotFoundError:
+    from evaluation.baseline.finetune_tsqa_plot import _time_series_to_pil
+
+
+def load_model_and_processor(base_model_id: str, lora_adapter_path: str = None):
+    """Load base model with optional LoRA adapters."""
+    print(f"Loading base model: {base_model_id}")
+
+    model = AutoModelForImageTextToText.from_pretrained(
+        base_model_id,
+        attn_implementation="flash_attention_2",
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        low_cpu_mem_usage=True,
+    )
+
+    if lora_adapter_path:
+        print(f"Loading LoRA adapters from: {lora_adapter_path}")
+        model = PeftModel.from_pretrained(model, lora_adapter_path)
+        processor = AutoProcessor.from_pretrained(lora_adapter_path)
+    else:
+        print("No LoRA adapters specified - using base model only")
+        processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")
+
+    model.eval()
+    print("Model and processor loaded successfully!")
+    return model, processor
+
+
+def run_inference(model, processor, messages, max_new_tokens=512, temperature=0.7):
+    """Run inference on a single example and return generated text."""
+    images = []
+    for msg in messages:
+        content = msg.get("content", [])
+        if not isinstance(content, list):
+            content = [content]
+        for element in content:
+            if isinstance(element, dict) and ("image" in element or element.get("type") == "image"):
+                image = element.get("image", element)
+                if image is not None and hasattr(image, "convert"):
+                    images.append(image.convert("RGB"))
+
+    text = processor.apply_chat_template(
+        messages, add_generation_prompt=True, tokenize=False
+    )
+
+    inputs = processor(
+        text=text,
+        images=images if images else None,
+        return_tensors="pt",
+        padding=True
+    )
+    inputs = {k: v.to(model.device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            do_sample=True if temperature > 0 else False,
+            pad_token_id=processor.tokenizer.pad_token_id,
+            eos_token_id=processor.tokenizer.eos_token_id,
+        )
+
+    generated_text = processor.decode(outputs[0], skip_special_tokens=True)
+    prompt_text = processor.decode(inputs["input_ids"][0], skip_special_tokens=True)
+    if generated_text.startswith(prompt_text):
+        generated_text = generated_text[len(prompt_text):].strip()
+
+    return generated_text
+
+
+def _build_messages_from_sample_for_inference(sample: dict) -> tuple:
+    """Build chat messages with time series plot. Returns (messages, user_text)."""
+    pre = (sample.get("pre_prompt") or "").strip()
+    post = (sample.get("post_prompt") or "").strip()
+
+    time_series = sample.get("time_series")
+    if time_series is None and "Series" in sample:
+        try:
+            time_series = json.loads(sample["Series"])
+        except Exception:
+            time_series = []
+
+    if time_series is None:
+        time_series = sample.get("original_data", sample.get("signal", []))
+
+    img = _time_series_to_pil(time_series)
+    user_text = "\n\n".join([pre, post])
+
+    messages = [
+        {
+            "role": "system",
+            "content": [{"type": "text", "text": "You are a helpful AI that analyzes time series data to answer questions."}],
+        },
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": user_text},
+                {"type": "image", "image": img},
+            ],
+        },
+    ]
+    return messages, user_text
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run inference with LoRA model on TSQA data")
+    parser.add_argument("--base-model", type=str, default="google/gemma-3-4b-pt")
+    parser.add_argument("--lora-path", type=str, default="runs/gemma3-4b-pt-tsqa-lora",
+                        help="Path to LoRA adapters. Set to 'none' or empty to use base model only.")
+    parser.add_argument("--max-new-tokens", type=int, default=256)
+    parser.add_argument("--temperature", type=float, default=0.7)
+    parser.add_argument("--split", type=str, default="test", choices=["train", "test", "validation"])
+    parser.add_argument("--output-csv", type=str, default="inference_tsqa_results.csv",
+                        help="Path to save results CSV file")
+    parser.add_argument("--max-samples", type=int, default=None,
+                        help="Maximum number of samples to process (default: all)")
+    args = parser.parse_args()
+
+    base_model_id = args.base_model
+    lora_adapter_path = args.lora_path if args.lora_path and args.lora_path.lower() != 'none' else None
+
+    model, processor = load_model_and_processor(base_model_id, lora_adapter_path)
+
+    print(f"\nLoading TSQA {args.split} split...")
+    ds = TSQADataset(split=args.split, EOS_TOKEN="")
+    print(f"Dataset size: {len(ds)}")
+
+    num_samples = len(ds) if args.max_samples is None else min(args.max_samples, len(ds))
+    print(f"Processing {num_samples} samples...\n")
+
+    results = []
+
+    for idx in tqdm(range(num_samples), desc="Running inference"):
+        sample = ds[idx]
+
+        ground_truth = (sample.get("answer") or sample.get("label") or "").strip()
+        messages, user_text = _build_messages_from_sample_for_inference(sample)
+        response = run_inference(model, processor, messages, max_new_tokens=args.max_new_tokens, temperature=args.temperature)
+
+        result = {
+            "sample_idx": idx,
+            "input_text": user_text,
+            "target_answer": ground_truth,
+            "generated_answer": response,
+        }
+        results.append(result)
+
+        if idx < 5:
+            print("\n" + "="*80)
+            print(f"SAMPLE {idx} from {args.split} split")
+            print("="*80)
+            print(f"\nQUESTION:\n{user_text}")
+            print(f"\nGROUND TRUTH ANSWER:\n{ground_truth}")
+            print(f"\nMODEL RESPONSE:\n{response}")
+            print("="*80)
+
+    print(f"\n\nSaving results to {args.output_csv}...")
+    with open(args.output_csv, 'w', newline='', encoding='utf-8') as csvfile:
+        fieldnames = ["sample_idx", "input_text", "target_answer", "generated_answer"]
+        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+        writer.writeheader()
+        for result in results:
+            writer.writerow(result)
+
+    print(f"Saved {len(results)} results to {args.output_csv}")
+    print("\n" + "="*80)
+    print("TSQA inference completed successfully!")
+    print("="*80)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/evaluation/baseline/run_with_memory_optimization.sh b/evaluation/baseline/run_with_memory_optimization.sh
new file mode 100644
index 00000000..93e53197
--- /dev/null
+++ b/evaluation/baseline/run_with_memory_optimization.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+# Memory optimization script for CUDA training
+# This sets PyTorch environment variables to reduce memory fragmentation
+
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128
+
+# Optional: Clear GPU memory before running
+python -c "import torch; torch.cuda.empty_cache()" 2>/dev/null || true
+
+# Run your training script with all arguments passed through
+python "$@"
diff --git a/evaluation/baseline/test_ecg_images.py b/evaluation/baseline/test_ecg_images.py
new file mode 100644
index 00000000..2dbcfb6b
--- /dev/null
+++ b/evaluation/baseline/test_ecg_images.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Test script to verify ECG-QA image pipeline.
+
+Saves images at two stages:
+1. Original: directly from _ecg_leads_to_pil
+2. Extracted: after going through messages dict and process_vision_info
+
+Run: python evaluation/baseline/test_ecg_images.py
+Check: test_images/ folder - images should match
+"""
+
+import os
+import sys
+
+PROJECT_SRC = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "src"))
+if PROJECT_SRC not in sys.path:
+    sys.path.insert(0, PROJECT_SRC)
+
+PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from time_series_datasets.ecg_qa.ECGQACoTQADataset import ECGQACoTQADataset
+
+from PIL import Image
+
+try:
+    from finetune_ecg_qa_plot import _get_ecg_id_from_sample, _build_messages_from_sample
+    from common_finetune_sft import process_vision_info, _load_ecg_data, _ecg_to_image
+except ModuleNotFoundError:
+    from evaluation.baseline.finetune_ecg_qa_plot import _get_ecg_id_from_sample, _build_messages_from_sample
+    from evaluation.baseline.common_finetune_sft import process_vision_info, _load_ecg_data, _ecg_to_image
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Test ECG-QA image pipeline")
+    parser.add_argument("--num-samples", type=int, default=3, help="Number of samples to test")
+    parser.add_argument("--output-dir", type=str, default="test_images", help="Output directory for images")
+    args = parser.parse_args()
+
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    print(f"Loading ECG-QA dataset...")
+    ds = ECGQACoTQADataset(split="train", EOS_TOKEN="", max_samples=args.num_samples)
+    print(f"Loaded {len(ds)} samples\n")
+
+    for i in range(min(args.num_samples, len(ds))):
+        sample = ds[i]
+        print(f"Sample {i}:")
+
+        # Stage 1: Generate image directly from raw ECG data
+        ecg_id = _get_ecg_id_from_sample(sample)
+        ecg_data = _load_ecg_data(ecg_id)
+        original_img = _ecg_to_image(ecg_data)
+        original_path = os.path.join(args.output_dir, f"sample_{i}_original.png")
+        original_img.save(original_path)
+        print(f"  Original image: {original_path} ({original_img.size})")
+
+        # Stage 2: Build messages and extract via process_vision_info
+        messages_dict = _build_messages_from_sample(sample, eos_token="")
+        messages = messages_dict["messages"]
+        extracted_images = process_vision_info(messages)
+
+        if extracted_images:
+            extracted_img = extracted_images[0]
+            extracted_path = os.path.join(args.output_dir, f"sample_{i}_extracted.png")
+            extracted_img.save(extracted_path)
+            print(f"  Extracted image: {extracted_path} ({extracted_img.size})")
+
+            # Quick check if they're the same size
+            if original_img.size == extracted_img.size:
+                print(f"  ✓ Sizes match")
+            else:
+                print(f"  ✗ Size mismatch!")
+        else:
+            print(f"  ✗ No image extracted from messages!")
+
+        print()
+
+    print(f"Done! Check images in: {args.output_dir}/")
+
+
+if __name__ == "__main__":
+    main()