Datasets:

anonymous4ai
/

AstroVLBench

#!/usr/bin/env python3
"""
Task 4: Light Curve Classification (AGN / SNIa / TDE / RRL / Mira)
Classifies astronomical transients and variables from light curve images
or text-based multi-band flux data.
"""

import argparse
import base64
import csv
import json
import os
import pathlib
import re
import time
from typing import Optional

from dotenv import load_dotenv
load_dotenv(override=True)

from openai import OpenAI


# =========================
# CONFIGURATION
# =========================

DATA_DIR = pathlib.Path(__file__).resolve().parent.parent.parent / "data" / "Task4_LightCurve"
CLASSES = ["AGN", "SNIa", "TDE", "RRL", "Mira"]

# Passband index -> LSST filter name and central wavelength (nm)
PASSBAND_MAP = {
    0: ("u", 365),
    1: ("g", 480),
    2: ("r", 620),
    3: ("i", 750),
    4: ("z", 870),
    5: ("y", 1000),
}


# =========================
# CLIENT
# =========================

def get_client(model: str) -> OpenAI:
    """Create OpenAI-compatible client based on model name.
    Requires environment variables:
      - OPENAI_API_KEY / OPENAI_BASE_URL for OpenAI/compatible models
      - CLAUDE_API_KEY for Claude models
      - GROK_API_KEY for Grok models
      - QWEN_API_KEY for Qwen models
      - INTERN_API_KEY for InternVL models
    """
    api_key = os.getenv("OPENAI_API_KEY")
    base_url = os.getenv("OPENAI_BASE_URL")

    if "intern" in model.lower():
        api_key = os.getenv("INTERN_API_KEY")
        base_url = os.getenv("INTERN_BASE_URL")
    elif "qwen" in model.lower():
        api_key = os.getenv("QWEN_API_KEY")
        base_url = os.getenv("QWEN_BASE_URL")
    elif "grok" in model.lower():
        api_key = os.getenv("GROK_API_KEY")
    elif "claude" in model.lower():
        api_key = os.getenv("CLAUDE_API_KEY")

    return OpenAI(api_key=api_key, base_url=base_url)


# =========================
# IMAGE UTILS
# =========================

def encode_image(path: pathlib.Path) -> str:
    with open(path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")


# =========================
# DATA LOADING
# =========================

def load_catalog_image(data_dir: pathlib.Path = DATA_DIR):
    samples = []
    for cls in CLASSES:
        fig_dir = data_dir / "figures" / cls
        if not fig_dir.exists():
            continue
        for fig in sorted(fig_dir.glob("*.png")):
            samples.append({
                "oid": fig.stem,
                "label": cls,
                "image_path": fig,
            })
    return samples


def load_catalog_text(data_dir: pathlib.Path = DATA_DIR):
    samples = []
    for cls in CLASSES:
        csv_dir = data_dir / "csv" / cls
        if not csv_dir.exists():
            continue
        for csv_file in sorted(csv_dir.glob("*.csv")):
            samples.append({
                "oid": csv_file.stem,
                "label": cls,
                "csv_path": csv_file,
            })
    return samples


def format_lightcurve(csv_path: pathlib.Path) -> str:
    rows = []
    with csv_path.open(newline="") as f:
        reader = csv.DictReader(f)
        for row in reader:
            rows.append(row)

    if not rows:
        return "No data available."

    by_band: dict[int, list] = {}
    for row in rows:
        try:
            pb = int(float(row["passband"]))
            mjd = float(row["mjd"])
            flux = float(row["flux"])
            flux_err = float(row["flux_err"])
            detected = int(float(row.get("detected_bool", 1)))
            by_band.setdefault(pb, []).append((mjd, flux, flux_err, detected))
        except (ValueError, KeyError):
            continue

    lines = []
    for pb in sorted(by_band.keys()):
        band_name, wave_nm = PASSBAND_MAP.get(pb, (f"band{pb}", 0))
        obs = by_band[pb]
        obs.sort(key=lambda x: x[0])
        lines.append(f"  {band_name}-band ({wave_nm} nm), {len(obs)} observations:")
        for mjd, flux, flux_err, detected in obs[:50]:
            det_str = "" if detected else " [non-detection]"
            lines.append(f"    MJD={mjd:.4f}  flux={flux:.3f} ± {flux_err:.3f}{det_str}")
        if len(obs) > 50:
            lines.append(f"    ... ({len(obs) - 50} more observations)")

    return "\n".join(lines)


# =========================
# PROMPTS
# =========================

SYSTEM_PROMPT_IMAGE = """You are an expert astrophysicist classifying astronomical transients and variables based on their light curve morphology.
Classify the source into exactly one of these 5 categories:
**AGN** — Stochastic, red-noise variability driven by accretion disk fluctuations around a supermassive black hole. Continuous process with no defined periodicity, persisting over long epochs.
**SNIa** — Thermonuclear explosion of a white dwarf. Fast rise to peak brightness followed by a characteristic exponential decline powered by radioactive decay (weeks timescale). A one-time event.
**TDE** — Tidal Disruption Event: a star disrupted by a supermassive black hole. Rapid rise followed by a smooth power-law decline as stellar debris falls back. Sustained high-temperature emission.
**RRL** — RR Lyrae: short-period pulsating star with a period of hours to ~1 day. Strictly periodic, sawtooth-like light curve with rapid rise and slow decline.
**Mira** — Long-period pulsating AGB star. Periodic variability over months to years, with large amplitude and smooth sinusoidal-like variations.
**Output requirements:**
- Respond with a JSON object: {"answer": "", "reason": ""}
- The "answer" field must be exactly one of: AGN, SNIa, TDE, RRL, Mira
- The "reason" field should contain a brief explanation of your classification decision
- Do not include any text outside the JSON object
"""

SYSTEM_PROMPT_IMAGE_WOGUIDE = """Classify this light curve into one of: AGN, SNIa, TDE, RRL, Mira.
Output requirements:
- Respond with a JSON object: {"answer": "", "reason": ""}
- The "answer" field must be exactly one of: AGN, SNIa, TDE, RRL, Mira
- The "reason" field should contain a brief explanation of your classification decision
- Do not include any text outside the JSON object
"""

SYSTEM_PROMPT_TEXT = """You are an expert astrophysicist classifying astronomical transients and variables based solely on their underlying physical processes.
You will be given multi-band observational flux data (flux in arbitrary units vs. Modified Julian Date). Classify the target into exactly one of the 5 categories below. Evaluate the implied timescales, periodicity, event continuity, and behavior across wavelengths. Base your answer on physical deduction alone.
**AGN** — Stochastic, red-noise variability driven by accretion disk fluctuations around a supermassive black hole. Continuous process lacking any defined global periodicity, persisting over extremely long epochs.
**SNIa** — Thermonuclear explosion of a white dwarf at the Chandrasekhar mass limit. Powered by radioactive decay (⁵⁶Ni → ⁵⁶Co → ⁵⁶Fe). Rapid rise to peak, then characteristic exponential decline over weeks. A single, non-repeating event.
**TDE** — Tidal Disruption Event: a star disrupted by a dormant supermassive black hole. Steady fallback of stellar debris forms a temporary accretion disk. Rapid rise followed by a smooth power-law decline; sustained high-temperature emission.
**RRL** — RR Lyrae: low-mass horizontal branch star with rapid radial pulsations. Strictly periodic, with period of hours to ~1 day. Sawtooth-like profile with fast rise and slow decline.
**Mira** — Asymptotic Giant Branch star undergoing fundamental-mode radial pulsations. Large-amplitude, long-period variability spanning months to years. Smooth, quasi-sinusoidal variations.
**Output requirements:**
- Respond with a JSON object: {"answer": "", "reason": ""}
- The "answer" field must be exactly one of: AGN, SNIa, TDE, RRL, Mira
- The "reason" field should contain a brief explanation based on the light curve properties
- Do not include any text outside the JSON object
"""

USER_TEXT_IMAGE = "Classify this light curve: AGN, SNIa, TDE, RRL, or Mira. Respond with JSON format."


# =========================
# MODEL CALLS
# =========================

def classify_image(client: OpenAI, image_path: pathlib.Path, model: str, system_prompt: str, max_completion_tokens: int):
    img_b64 = encode_image(image_path)

    messages = [
        {"role": "system", "content": system_prompt},
        {
            "role": "user",
            "content": [
                {"type": "text", "text": USER_TEXT_IMAGE},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{img_b64}",
                        "detail": "high",
                    },
                },
            ],
        },
    ]

    extra = {"enable_thinking": False} if "qwen" in model.lower() else {}
    for attempt in range(5):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                temperature=0,
                max_completion_tokens=max_completion_tokens,
                extra_body=extra if extra else None,
            )
            return response
        except Exception as e:
            if attempt < 4:
                wait = 2 ** attempt * 5
                print(f"  Attempt {attempt+1} failed ({e}), retrying in {wait}s...")
                time.sleep(wait)
            else:
                raise


def classify_text(client: OpenAI, user_prompt: str, model: str, max_completion_tokens: int):
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT_TEXT},
        {"role": "user", "content": user_prompt},
    ]

    extra = {"enable_thinking": False} if "qwen" in model.lower() else {}
    for attempt in range(5):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                temperature=0,
                max_completion_tokens=max_completion_tokens,
                extra_body=extra if extra else None,
            )
            return response
        except Exception as e:
            if attempt < 4:
                wait = 2 ** attempt * 5
                print(f"  Attempt {attempt+1} failed ({e}), retrying in {wait}s...")
                time.sleep(wait)
            else:
                raise


# =========================
# PARSE PREDICTION
# =========================

def parse_prediction(raw: str) -> dict:
    cleaned = re.sub(r"```json\s*", "", raw)
    cleaned = re.sub(r"```\s*", "", cleaned)
    cleaned = cleaned.strip()
    try:
        return json.loads(cleaned)
    except json.JSONDecodeError:
        return {"answer": raw, "reason": ""}


def canonicalize_label(value: str) -> str:
    val = (value or "").strip()
    val_up = val.upper()
    if "AGN" in val_up:
        return "AGN"
    if "SNIA" in val_up or "SN IA" in val_up or "TYPE IA" in val_up or val_up == "SN":
        return "SNIa"
    if "TDE" in val_up or "TIDAL" in val_up:
        return "TDE"
    if "RRL" in val_up or "RR LYR" in val_up:
        return "RRL"
    if "MIRA" in val_up:
        return "Mira"
    return "Unknown"


# =========================
# MAIN PIPELINE
# =========================

def run(
    model: str,
    limit: Optional[int],
    results_dir: pathlib.Path,
    modality: str,
    prompt_type: str,
    max_completion_tokens: int,
    resume: bool,
    data_dir: pathlib.Path = DATA_DIR,
) -> pathlib.Path:

    client = get_client(model)

    if modality == "image":
        samples = load_catalog_image(data_dir)
    else:
        samples = load_catalog_text(data_dir)
    print(f"Loaded {len(samples)} samples")

    results_dir.mkdir(parents=True, exist_ok=True)
    out_path = results_dir / f"predictions-{modality}-{prompt_type}-{model}.json"

    results = []
    processed_ids = set()
    if resume and out_path.exists():
        with out_path.open("r") as f:
            results = json.load(f)
            processed_ids = {r.get("oid") or r.get("image") for r in results}
        print(f"Resuming from {len(results)} existing predictions")

    correct = sum(r["correct"] for r in results)
    total = len(results)

    if prompt_type == "guided":
        system_prompt = SYSTEM_PROMPT_IMAGE
    else:
        system_prompt = SYSTEM_PROMPT_IMAGE_WOGUIDE

    for i, sample in enumerate(samples):
        if limit is not None and i >= limit:
            break

        oid = sample["oid"]
        if oid in processed_ids:
            continue

        label = sample["label"]

        if modality == "image":
            response = classify_image(client, sample["image_path"], model, system_prompt, max_completion_tokens)
        else:
            lightcurve_text = format_lightcurve(sample["csv_path"])
            user_prompt = f"Multi-band light curve data:\n\n{lightcurve_text}\n\nBased on the physical processes described, classify this source. Respond with JSON format."
            response = classify_text(client, user_prompt, model, max_completion_tokens)

        content = response.choices[0].message.content
        pred = parse_prediction(content)
        answer = canonicalize_label(pred.get("answer", ""))
        is_correct = answer == label

        total += 1
        correct += int(is_correct)

        results.append({
            "oid": oid,
            "label": label,
            "prediction": pred,
            "correct": int(is_correct),
            "raw_response": response.model_dump(),
        })
        print(f"{oid}: pred={answer} label={label} {'✓' if is_correct else '✗'}")

        with out_path.open("w") as f:
            json.dump(results, f, indent=2)

    if total > 0:
        print(f"Accuracy on {total} checked: {correct}/{total} = {correct/total:.2%}")

    print(f"Saved predictions to {out_path}")
    return out_path


# =========================
# ARGPARSE
# =========================

def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Task4: Light Curve Classification")
    parser.add_argument("--model", default="gpt-4o")
    parser.add_argument("--modality", choices=["image", "text"], default="image")
    parser.add_argument("--prompt-type", choices=["guided", "woguide"], default="guided")
    parser.add_argument("--limit", type=int, default=None)
    parser.add_argument("--results-dir", type=pathlib.Path, default=pathlib.Path("./results"))
    parser.add_argument("--max-completion-tokens", type=int, default=16384)
    parser.add_argument("--resume", action="store_true")
    parser.add_argument("--data-dir", type=pathlib.Path, default=DATA_DIR)
    return parser.parse_args()


if __name__ == "__main__":
    args = parse_args()
    run(
        model=args.model,
        limit=args.limit,
        results_dir=args.results_dir,
        modality=args.modality,
        prompt_type=args.prompt_type,
        max_completion_tokens=args.max_completion_tokens,
        resume=args.resume,
        data_dir=args.data_dir,
    )

	#!/usr/bin/env python3
	"""
	Task 4: Light Curve Classification (AGN / SNIa / TDE / RRL / Mira)

	Classifies astronomical transients and variables from light curve images
	or text-based multi-band flux data.
	"""

	import argparse
	import base64
	import csv
	import json
	import os
	import pathlib
	import re
	import time
	from typing import Optional

	from dotenv import load_dotenv
	load_dotenv(override=True)

	from openai import OpenAI


	# =========================
	# CONFIGURATION
	# =========================

	DATA_DIR = pathlib.Path(__file__).resolve().parent.parent.parent / "data" / "Task4_LightCurve"
	CLASSES = ["AGN", "SNIa", "TDE", "RRL", "Mira"]

	# Passband index -> LSST filter name and central wavelength (nm)
	PASSBAND_MAP = {
	0: ("u", 365),
	1: ("g", 480),
	2: ("r", 620),
	3: ("i", 750),
	4: ("z", 870),
	5: ("y", 1000),
	}


	# =========================
	# CLIENT
	# =========================

	def get_client(model: str) -> OpenAI:
	"""Create OpenAI-compatible client based on model name.

	Requires environment variables:
	- OPENAI_API_KEY / OPENAI_BASE_URL for OpenAI/compatible models
	- CLAUDE_API_KEY for Claude models
	- GROK_API_KEY for Grok models
	- QWEN_API_KEY for Qwen models
	- INTERN_API_KEY for InternVL models
	"""
	api_key = os.getenv("OPENAI_API_KEY")
	base_url = os.getenv("OPENAI_BASE_URL")

	if "intern" in model.lower():
	api_key = os.getenv("INTERN_API_KEY")
	base_url = os.getenv("INTERN_BASE_URL")
	elif "qwen" in model.lower():
	api_key = os.getenv("QWEN_API_KEY")
	base_url = os.getenv("QWEN_BASE_URL")
	elif "grok" in model.lower():
	api_key = os.getenv("GROK_API_KEY")
	elif "claude" in model.lower():
	api_key = os.getenv("CLAUDE_API_KEY")

	return OpenAI(api_key=api_key, base_url=base_url)


	# =========================
	# IMAGE UTILS
	# =========================

	def encode_image(path: pathlib.Path) -> str:
	with open(path, "rb") as f:
	return base64.b64encode(f.read()).decode("utf-8")


	# =========================
	# DATA LOADING
	# =========================

	def load_catalog_image(data_dir: pathlib.Path = DATA_DIR):
	samples = []
	for cls in CLASSES:
	fig_dir = data_dir / "figures" / cls
	if not fig_dir.exists():
	continue
	for fig in sorted(fig_dir.glob("*.png")):
	samples.append({
	"oid": fig.stem,
	"label": cls,
	"image_path": fig,
	})
	return samples


	def load_catalog_text(data_dir: pathlib.Path = DATA_DIR):
	samples = []
	for cls in CLASSES:
	csv_dir = data_dir / "csv" / cls
	if not csv_dir.exists():
	continue
	for csv_file in sorted(csv_dir.glob("*.csv")):
	samples.append({
	"oid": csv_file.stem,
	"label": cls,
	"csv_path": csv_file,
	})
	return samples


	def format_lightcurve(csv_path: pathlib.Path) -> str:
	rows = []
	with csv_path.open(newline="") as f:
	reader = csv.DictReader(f)
	for row in reader:
	rows.append(row)

	if not rows:
	return "No data available."

	by_band: dict[int, list] = {}
	for row in rows:
	try:
	pb = int(float(row["passband"]))
	mjd = float(row["mjd"])
	flux = float(row["flux"])
	flux_err = float(row["flux_err"])
	detected = int(float(row.get("detected_bool", 1)))
	by_band.setdefault(pb, []).append((mjd, flux, flux_err, detected))
	except (ValueError, KeyError):
	continue

	lines = []
	for pb in sorted(by_band.keys()):
	band_name, wave_nm = PASSBAND_MAP.get(pb, (f"band{pb}", 0))
	obs = by_band[pb]
	obs.sort(key=lambda x: x[0])
	lines.append(f" {band_name}-band ({wave_nm} nm), {len(obs)} observations:")
	for mjd, flux, flux_err, detected in obs[:50]:
	det_str = "" if detected else " [non-detection]"
	lines.append(f" MJD={mjd:.4f} flux={flux:.3f} ± {flux_err:.3f}{det_str}")
	if len(obs) > 50:
	lines.append(f" ... ({len(obs) - 50} more observations)")

	return "\n".join(lines)


	# =========================
	# PROMPTS
	# =========================

	SYSTEM_PROMPT_IMAGE = """You are an expert astrophysicist classifying astronomical transients and variables based on their light curve morphology.

	Classify the source into exactly one of these 5 categories:

	AGN — Stochastic, red-noise variability driven by accretion disk fluctuations around a supermassive black hole. Continuous process with no defined periodicity, persisting over long epochs.

	SNIa — Thermonuclear explosion of a white dwarf. Fast rise to peak brightness followed by a characteristic exponential decline powered by radioactive decay (weeks timescale). A one-time event.

	TDE — Tidal Disruption Event: a star disrupted by a supermassive black hole. Rapid rise followed by a smooth power-law decline as stellar debris falls back. Sustained high-temperature emission.

	RRL — RR Lyrae: short-period pulsating star with a period of hours to ~1 day. Strictly periodic, sawtooth-like light curve with rapid rise and slow decline.

	Mira — Long-period pulsating AGB star. Periodic variability over months to years, with large amplitude and smooth sinusoidal-like variations.

	Output requirements:
	- Respond with a JSON object: {"answer": "", "reason": ""}
	- The "answer" field must be exactly one of: AGN, SNIa, TDE, RRL, Mira
	- The "reason" field should contain a brief explanation of your classification decision
	- Do not include any text outside the JSON object
	"""

	SYSTEM_PROMPT_IMAGE_WOGUIDE = """Classify this light curve into one of: AGN, SNIa, TDE, RRL, Mira.

	Output requirements:
	- Respond with a JSON object: {"answer": "", "reason": ""}
	- The "answer" field must be exactly one of: AGN, SNIa, TDE, RRL, Mira
	- The "reason" field should contain a brief explanation of your classification decision
	- Do not include any text outside the JSON object
	"""

	SYSTEM_PROMPT_TEXT = """You are an expert astrophysicist classifying astronomical transients and variables based solely on their underlying physical processes.

	You will be given multi-band observational flux data (flux in arbitrary units vs. Modified Julian Date). Classify the target into exactly one of the 5 categories below. Evaluate the implied timescales, periodicity, event continuity, and behavior across wavelengths. Base your answer on physical deduction alone.

	AGN — Stochastic, red-noise variability driven by accretion disk fluctuations around a supermassive black hole. Continuous process lacking any defined global periodicity, persisting over extremely long epochs.

	SNIa — Thermonuclear explosion of a white dwarf at the Chandrasekhar mass limit. Powered by radioactive decay (⁵⁶Ni → ⁵⁶Co → ⁵⁶Fe). Rapid rise to peak, then characteristic exponential decline over weeks. A single, non-repeating event.

	TDE — Tidal Disruption Event: a star disrupted by a dormant supermassive black hole. Steady fallback of stellar debris forms a temporary accretion disk. Rapid rise followed by a smooth power-law decline; sustained high-temperature emission.

	RRL — RR Lyrae: low-mass horizontal branch star with rapid radial pulsations. Strictly periodic, with period of hours to ~1 day. Sawtooth-like profile with fast rise and slow decline.

	Mira — Asymptotic Giant Branch star undergoing fundamental-mode radial pulsations. Large-amplitude, long-period variability spanning months to years. Smooth, quasi-sinusoidal variations.

	Output requirements:
	- Respond with a JSON object: {"answer": "", "reason": ""}
	- The "answer" field must be exactly one of: AGN, SNIa, TDE, RRL, Mira
	- The "reason" field should contain a brief explanation based on the light curve properties
	- Do not include any text outside the JSON object
	"""

	USER_TEXT_IMAGE = "Classify this light curve: AGN, SNIa, TDE, RRL, or Mira. Respond with JSON format."


	# =========================
	# MODEL CALLS
	# =========================

	def classify_image(client: OpenAI, image_path: pathlib.Path, model: str, system_prompt: str, max_completion_tokens: int):
	img_b64 = encode_image(image_path)

	messages = [
	{"role": "system", "content": system_prompt},
	{
	"role": "user",
	"content": [
	{"type": "text", "text": USER_TEXT_IMAGE},
	{
	"type": "image_url",
	"image_url": {
	"url": f"data:image/png;base64,{img_b64}",
	"detail": "high",
	},
	},
	],
	},
	]

	extra = {"enable_thinking": False} if "qwen" in model.lower() else {}
	for attempt in range(5):
	try:
	response = client.chat.completions.create(
	model=model,
	messages=messages,
	temperature=0,
	max_completion_tokens=max_completion_tokens,
	extra_body=extra if extra else None,
	)
	return response
	except Exception as e:
	if attempt < 4:
	wait = 2 ** attempt * 5
	print(f" Attempt {attempt+1} failed ({e}), retrying in {wait}s...")
	time.sleep(wait)
	else:
	raise


	def classify_text(client: OpenAI, user_prompt: str, model: str, max_completion_tokens: int):
	messages = [
	{"role": "system", "content": SYSTEM_PROMPT_TEXT},
	{"role": "user", "content": user_prompt},
	]

	extra = {"enable_thinking": False} if "qwen" in model.lower() else {}
	for attempt in range(5):
	try:
	response = client.chat.completions.create(
	model=model,
	messages=messages,
	temperature=0,
	max_completion_tokens=max_completion_tokens,
	extra_body=extra if extra else None,
	)
	return response
	except Exception as e:
	if attempt < 4:
	wait = 2 ** attempt * 5
	print(f" Attempt {attempt+1} failed ({e}), retrying in {wait}s...")
	time.sleep(wait)
	else:
	raise


	# =========================
	# PARSE PREDICTION
	# =========================

	def parse_prediction(raw: str) -> dict:
	cleaned = re.sub(r"```json\s*", "", raw)
	cleaned = re.sub(r"```\s*", "", cleaned)
	cleaned = cleaned.strip()
	try:
	return json.loads(cleaned)
	except json.JSONDecodeError:
	return {"answer": raw, "reason": ""}


	def canonicalize_label(value: str) -> str:
	val = (value or "").strip()
	val_up = val.upper()
	if "AGN" in val_up:
	return "AGN"
	if "SNIA" in val_up or "SN IA" in val_up or "TYPE IA" in val_up or val_up == "SN":
	return "SNIa"
	if "TDE" in val_up or "TIDAL" in val_up:
	return "TDE"
	if "RRL" in val_up or "RR LYR" in val_up:
	return "RRL"
	if "MIRA" in val_up:
	return "Mira"
	return "Unknown"


	# =========================
	# MAIN PIPELINE
	# =========================

	def run(
	model: str,
	limit: Optional[int],
	results_dir: pathlib.Path,
	modality: str,
	prompt_type: str,
	max_completion_tokens: int,
	resume: bool,
	data_dir: pathlib.Path = DATA_DIR,
	) -> pathlib.Path:

	client = get_client(model)

	if modality == "image":
	samples = load_catalog_image(data_dir)
	else:
	samples = load_catalog_text(data_dir)
	print(f"Loaded {len(samples)} samples")

	results_dir.mkdir(parents=True, exist_ok=True)
	out_path = results_dir / f"predictions-{modality}-{prompt_type}-{model}.json"

	results = []
	processed_ids = set()
	if resume and out_path.exists():
	with out_path.open("r") as f:
	results = json.load(f)
	processed_ids = {r.get("oid") or r.get("image") for r in results}
	print(f"Resuming from {len(results)} existing predictions")

	correct = sum(r["correct"] for r in results)
	total = len(results)

	if prompt_type == "guided":
	system_prompt = SYSTEM_PROMPT_IMAGE
	else:
	system_prompt = SYSTEM_PROMPT_IMAGE_WOGUIDE

	for i, sample in enumerate(samples):
	if limit is not None and i >= limit:
	break

	oid = sample["oid"]
	if oid in processed_ids:
	continue

	label = sample["label"]

	if modality == "image":
	response = classify_image(client, sample["image_path"], model, system_prompt, max_completion_tokens)
	else:
	lightcurve_text = format_lightcurve(sample["csv_path"])
	user_prompt = f"Multi-band light curve data:\n\n{lightcurve_text}\n\nBased on the physical processes described, classify this source. Respond with JSON format."
	response = classify_text(client, user_prompt, model, max_completion_tokens)

	content = response.choices[0].message.content
	pred = parse_prediction(content)
	answer = canonicalize_label(pred.get("answer", ""))
	is_correct = answer == label

	total += 1
	correct += int(is_correct)

	results.append({
	"oid": oid,
	"label": label,
	"prediction": pred,
	"correct": int(is_correct),
	"raw_response": response.model_dump(),
	})
	print(f"{oid}: pred={answer} label={label} {'✓' if is_correct else '✗'}")

	with out_path.open("w") as f:
	json.dump(results, f, indent=2)

	if total > 0:
	print(f"Accuracy on {total} checked: {correct}/{total} = {correct/total:.2%}")

	print(f"Saved predictions to {out_path}")
	return out_path


	# =========================
	# ARGPARSE
	# =========================

	def parse_args() -> argparse.Namespace:
	parser = argparse.ArgumentParser(description="Task4: Light Curve Classification")
	parser.add_argument("--model", default="gpt-4o")
	parser.add_argument("--modality", choices=["image", "text"], default="image")
	parser.add_argument("--prompt-type", choices=["guided", "woguide"], default="guided")
	parser.add_argument("--limit", type=int, default=None)
	parser.add_argument("--results-dir", type=pathlib.Path, default=pathlib.Path("./results"))
	parser.add_argument("--max-completion-tokens", type=int, default=16384)
	parser.add_argument("--resume", action="store_true")
	parser.add_argument("--data-dir", type=pathlib.Path, default=DATA_DIR)
	return parser.parse_args()


	if __name__ == "__main__":
	args = parse_args()
	run(
	model=args.model,
	limit=args.limit,
	results_dir=args.results_dir,
	modality=args.modality,
	prompt_type=args.prompt_type,
	max_completion_tokens=args.max_completion_tokens,
	resume=args.resume,
	data_dir=args.data_dir,
	)