| |
| """ |
| Task 1: QSO Host Galaxy Classification (AGN vs Galaxy) |
| |
| Classifies galaxy images using vision LLMs with a physics-based prompt |
| focusing on accretion disk vs stellar bulge emission mechanisms. |
| """ |
|
|
| 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 |
|
|
|
|
| |
| |
| |
|
|
| DATA_DIR = pathlib.Path(__file__).resolve().parent.parent.parent / "data" / "Task1_QSOHost" |
|
|
|
|
| |
| |
| |
|
|
| 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) |
|
|
|
|
| |
| |
| |
|
|
| def encode_image(path: pathlib.Path) -> str: |
| with open(path, "rb") as f: |
| return base64.b64encode(f.read()).decode("utf-8") |
|
|
|
|
| |
| |
| |
|
|
| SYSTEM_PROMPT_GUIDED = """**Task:** Classify this image as either AGN or Galaxy. |
| |
| **Instructions:** |
| Both categories are massive galaxies consisting of billions of stars spread over thousands of light-years. The distinction lies entirely in the physical mechanism dominating the very core: |
| - Normal Galaxy: The light emission from the central region is purely the collective glow of the inner stellar populations, typically forming a central "bulge." A bulge is a massive, spheroidal concentration of older stars. While the stellar density naturally increases and peaks at the very center, the emission remains fundamentally rooted in a thermal population distributed across a spatial volume spanning hundreds to thousands of light-years. |
| - Type-1 AGN: In addition to the host galaxy's extended stellar components (like the disk and the central bulge), the exact geometric center hosts a supermassive black hole with an active accretion disk. This disk emits a staggering amount of radiative energy from a physically microscopic volume (often just light-days across). This results in a hyper-luminous, practically dimensionless energy source sitting directly on top of the extended stellar bulge. |
| |
| Examine the image, focusing on the interplay between the central emission and the extended host structure. Rely on your understanding of how these underlying physical realities would naturally manifest visually: |
| - If your analysis indicates the *presence* of an active accretion disk governing the core's emission, respond: AGN |
| - If your analysis indicates the core is purely governed by distributed stellar emission (e.g., the bulge) without an overpowering active black hole component, respond: Galaxy |
| |
| **Output requirements:** |
| - Respond with a JSON object in the following format: {"answer": "", "reason": ""} |
| - The "answer" field must be either: AGN or Galaxy |
| - The "reason" field should contain a brief explanation of your classification decision, explicitly linking the visual manifestation to the physical presence or absence of the central accretion disk versus a purely stellar bulge. |
| - Do not include any text outside the JSON object""" |
|
|
| SYSTEM_PROMPT_WOGUIDE = """Classify this galaxy image as either AGN or Galaxy. |
| Output requirements: |
| - Respond with a JSON object in the following format: {"answer": "", "reason": ""} |
| - The "answer" field must be either: AGN or Galaxy |
| - The "reason" field should contain a brief explanation of your classification decision |
| - Do not include any text outside the JSON object""" |
|
|
| SYSTEM_PROMPT_PHENOMENOLOGICAL = """**Task:** Classify this image as either AGN or Galaxy. |
| |
| **Instructions:** |
| Examine the central region of this galaxy image in high detail. Follow these steps internally: |
| 1. Analyze core sharpness: determine whether the core is an unresolved point source (PSF-like) or a resolved, extended structure. |
| 2. Check for optical artifacts such as diffraction spikes or saturation bleeding. |
| 3. Evaluate the transition from the center to the disk: smooth and gradual (bulge-like) versus a sharp point superposed on extended light (AGN-like). |
| - If the center is dominated by an unresolved point source consistent with a Type-1 AGN, respond: AGN |
| - If the center is dominated by a resolved stellar bulge, respond: Galaxy |
| |
| **Output requirements:** |
| - Respond with a JSON object in the following format: {"answer": "", "reason": ""} |
| - The "answer" field must be either: AGN or Galaxy |
| - The "reason" field should contain a brief explanation of your classification decision |
| - Do not include any text outside the JSON object""" |
|
|
| USER_TEXT = "Label this image based on the underlying physical emission mechanisms present. Respond with JSON format." |
|
|
|
|
| |
| |
| |
|
|
| 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}, |
| { |
| "type": "image_url", |
| "image_url": { |
| "url": f"data:image/jpeg;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 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 run( |
| csv_path: pathlib.Path, |
| root: pathlib.Path, |
| model: str, |
| limit: Optional[int], |
| results_dir: pathlib.Path, |
| prompt_type: str, |
| max_completion_tokens: int, |
| resume: bool, |
| ) -> pathlib.Path: |
|
|
| client = get_client(model) |
|
|
| if prompt_type == "guided": |
| system_prompt = SYSTEM_PROMPT_GUIDED |
| elif prompt_type == "woguide": |
| system_prompt = SYSTEM_PROMPT_WOGUIDE |
| elif prompt_type == "phenomenological": |
| system_prompt = SYSTEM_PROMPT_PHENOMENOLOGICAL |
| else: |
| raise ValueError(f"Unknown prompt type: {prompt_type}") |
|
|
| rows = list(csv.DictReader(csv_path.open())) |
| results_dir.mkdir(parents=True, exist_ok=True) |
|
|
| out_path = results_dir / f"predictions-{prompt_type}-{model}.json" |
|
|
| results = [] |
| processed_images = set() |
| if resume and out_path.exists(): |
| with out_path.open("r") as f: |
| results = json.load(f) |
| processed_images = {r["image"] for r in results} |
| print(f"Resuming from {len(results)} existing predictions") |
|
|
| correct = sum(r["correct"] for r in results) |
| total = len(results) |
|
|
| for i, row in enumerate(rows): |
| if limit is not None and i >= limit: |
| break |
|
|
| image_path = (root / row["image"]).resolve() |
| if str(image_path) in processed_images: |
| continue |
|
|
| label = row["label"].strip() |
|
|
| response = classify_image(client, image_path, model, system_prompt, max_completion_tokens) |
| content = response.choices[0].message.content |
| pred = parse_prediction(content) |
| answer = pred.get("answer", "") |
| is_correct = answer.strip().lower() == label.lower() |
|
|
| total += 1 |
| correct += int(is_correct) |
|
|
| results.append({ |
| "image": str(image_path), |
| "label": label, |
| "prediction": pred, |
| "correct": int(is_correct), |
| "raw_response": response.model_dump(), |
| }) |
| print(f"{image_path.name}: 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 |
|
|
|
|
| |
| |
| |
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description="Task1: QSO Host Galaxy Classification") |
| parser.add_argument("--csv", type=pathlib.Path, default=DATA_DIR / "image_labels.csv") |
| parser.add_argument("--root", type=pathlib.Path, default=DATA_DIR) |
| parser.add_argument("--model", default="gpt-4o") |
| parser.add_argument("--prompt-type", choices=["guided", "woguide", "phenomenological"], 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") |
| return parser.parse_args() |
|
|
|
|
| if __name__ == "__main__": |
| args = parse_args() |
| run( |
| csv_path=args.csv, |
| root=args.root, |
| model=args.model, |
| limit=args.limit, |
| results_dir=args.results_dir, |
| prompt_type=args.prompt_type, |
| max_completion_tokens=args.max_completion_tokens, |
| resume=args.resume, |
| ) |
|
|
