opro/opro_demo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: implement true OPRO with Gemini-style UI

Browse Source 
- Add true OPRO system instruction optimization (vs query rewriting)
- Implement iterative optimization with performance trajectory
- Add new OPRO API endpoints (/opro/create, /opro/generate_and_evaluate, /opro/execute)
- Create modern Gemini-style chat UI (frontend/opro.html)
- Optimize performance: reduce candidates from 20 to 10 (2x faster)
- Add model selector in UI toolbar
- Add collapsible sidebar with session management
- Add copy button for instructions
- Ensure all generated prompts use simplified Chinese
- Update README with comprehensive documentation
- Add .gitignore for local_docs folder
This commit is contained in:
leehwui
2025-12-06 17:24:28 +08:00
parent 8f52fad41c
commit 1376d60ed5
10 changed files with 1817 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

374
_qwen_xinference_demo/api.py
View File

@@ -2,14 +2,30 @@ from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import RedirectResponse, FileResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel
from typing import List, Tuple, Optional
import config
# Legacy session management (query rewriting)
from .opro.session_state import create_session, get_session, update_session_add_candidates, log_user_choice
from .opro.session_state import log_user_reject
from .opro.session_state import set_selected_prompt, log_chat_message
from .opro.session_state import set_session_model
from .opro.session_state import USER_FEEDBACK_LOG
# True OPRO session management
from .opro.session_state import (
create_opro_run, get_opro_run, update_opro_iteration,
add_opro_evaluation, get_opro_trajectory, set_opro_test_cases,
complete_opro_run, list_opro_runs
)
# Optimization functions
from .opro.user_prompt_optimizer import generate_candidates
from .opro.user_prompt_optimizer import (
generate_system_instruction_candidates,
evaluate_system_instruction
)
from .opro.ollama_client import call_qwen
from .opro.ollama_client import list_models
@@ -23,8 +39,9 @@ app = FastAPI(
openapi_tags=[
{"name": "health", "description": "健康检查"},
{"name": "models", "description": "模型列表与设置"},
{"name": "sessions", "description": "会话管理"},
{"name": "opro", "description": "提示优化候选生成与选择/拒绝"},
{"name": "sessions", "description": "会话管理（旧版查询重写）"},
{"name": "opro-legacy", "description": "旧版提示优化（查询重写）"},
{"name": "opro-true", "description": "真正的OPRO（系统指令优化）"},
{"name": "chat", "description": "会话聊天"},
{"name": "ui", "description": "静态页面"}
]
@@ -89,14 +106,69 @@ class SetModelReq(BaseModel):
session_id: str
model_name: str
@app.post("/start", tags=["opro"])
# ============================================================================
# TRUE OPRO REQUEST MODELS
# ============================================================================
class TestCase(BaseModel):
"""A single test case for OPRO evaluation."""
input: str
expected_output: str
class CreateOPRORunReq(BaseModel):
"""Request to create a new OPRO optimization run."""
task_description: str
test_cases: Optional[List[TestCase]] = None
model_name: Optional[str] = None
class OPROIterateReq(BaseModel):
"""Request to run one OPRO iteration."""
run_id: str
top_k: Optional[int] = None
class OPROEvaluateReq(BaseModel):
"""Request to evaluate a system instruction."""
run_id: str
instruction: str
class OPROAddTestCasesReq(BaseModel):
"""Request to add test cases to an OPRO run."""
run_id: str
test_cases: List[TestCase]
class OPROGenerateAndEvaluateReq(BaseModel):
"""Request to generate and auto-evaluate candidates (for chat-like UX)."""
run_id: str
top_k: Optional[int] = None
pool_size: Optional[int] = None
auto_evaluate: Optional[bool] = True # If False, use diversity-based selection only
class OPROExecuteReq(BaseModel):
"""Request to execute a system instruction with user input."""
instruction: str
user_input: str
model_name: Optional[str] = None
# ============================================================================
# LEGACY ENDPOINTS (Query Rewriting - NOT true OPRO)
# ============================================================================
@app.post("/start", tags=["opro-legacy"])
def start(req: StartReq):
sid = create_session(req.query)
cands = generate_candidates(req.query, [], model_name=get_session(sid).get("model_name"))
update_session_add_candidates(sid, cands)
return ok({"session_id": sid, "round": 0, "candidates": cands})
@app.post("/next", tags=["opro"])
@app.post("/next", tags=["opro-legacy"])
def next_round(req: NextReq):
s = get_session(req.session_id)
if not s:
@@ -110,7 +182,7 @@ def next_round(req: NextReq):
update_session_add_candidates(req.session_id, cands)
return ok({"session_id": req.session_id, "round": s["round"], "candidates": cands})
@app.post("/select", tags=["opro"])
@app.post("/select", tags=["opro-legacy"])
def select(req: SelectReq):
s = get_session(req.session_id)
if not s:
@@ -138,7 +210,7 @@ def select(req: SelectReq):
pass
return ok({"prompt": req.choice, "answer": ans})
@app.post("/reject", tags=["opro"])
@app.post("/reject", tags=["opro-legacy"])
def reject(req: RejectReq):
s = get_session(req.session_id)
if not s:
@@ -151,7 +223,7 @@ class QueryReq(BaseModel):
query: str
session_id: str | None = None
@app.post("/query", tags=["opro"])
@app.post("/query", tags=["opro-legacy"])
def query(req: QueryReq):
if req.session_id:
s = get_session(req.session_id)
@@ -240,7 +312,7 @@ def message(req: MessageReq):
class QueryFromMsgReq(BaseModel):
session_id: str
@app.post("/query_from_message", tags=["opro"])
@app.post("/query_from_message", tags=["opro-legacy"])
def query_from_message(req: QueryFromMsgReq):
s = get_session(req.session_id)
if not s:
@@ -258,7 +330,7 @@ def query_from_message(req: QueryFromMsgReq):
class AnswerReq(BaseModel):
query: str
@app.post("/answer", tags=["opro"])
@app.post("/answer", tags=["opro-legacy"])
def answer(req: AnswerReq):
sid = create_session(req.query)
log_chat_message(sid, "user", req.query)
@@ -282,3 +354,287 @@ def set_model(req: SetModelReq):
raise AppException(400, f"model not available: {req.model_name}", "MODEL_NOT_AVAILABLE")
set_session_model(req.session_id, req.model_name)
return ok({"session_id": req.session_id, "model_name": req.model_name})
# ============================================================================
# TRUE OPRO ENDPOINTS (System Instruction Optimization)
# ============================================================================
@app.post("/opro/create", tags=["opro-true"])
def opro_create_run(req: CreateOPRORunReq):
"""
Create a new OPRO optimization run.
This starts a new system instruction optimization process for a given task.
"""
# Convert test cases from Pydantic models to tuples
test_cases = None
if req.test_cases:
test_cases = [(tc.input, tc.expected_output) for tc in req.test_cases]
run_id = create_opro_run(
task_description=req.task_description,
test_cases=test_cases,
model_name=req.model_name
)
run = get_opro_run(run_id)
return ok({
"run_id": run_id,
"task_description": run["task_description"],
"num_test_cases": len(run["test_cases"]),
"iteration": run["iteration"],
"status": run["status"]
})
@app.post("/opro/iterate", tags=["opro-true"])
def opro_iterate(req: OPROIterateReq):
"""
Run one OPRO iteration: generate new system instruction candidates.
This generates optimized system instructions based on the performance trajectory.
"""
run = get_opro_run(req.run_id)
if not run:
raise AppException(404, "OPRO run not found", "RUN_NOT_FOUND")
# Get trajectory for optimization
trajectory = get_opro_trajectory(req.run_id)
# Generate candidates
top_k = req.top_k or config.TOP_K
try:
candidates = generate_system_instruction_candidates(
task_description=run["task_description"],
trajectory=trajectory if trajectory else None,
top_k=top_k,
model_name=run["model_name"]
)
except Exception as e:
raise AppException(500, f"Failed to generate candidates: {e}", "GENERATION_ERROR")
# Update run with new candidates
update_opro_iteration(req.run_id, candidates)
return ok({
"run_id": req.run_id,
"iteration": run["iteration"] + 1,
"candidates": candidates,
"num_candidates": len(candidates),
"best_score": run["best_score"]
})
@app.post("/opro/evaluate", tags=["opro-true"])
def opro_evaluate(req: OPROEvaluateReq):
"""
Evaluate a system instruction on the test cases.
This scores the instruction and updates the performance trajectory.
"""
run = get_opro_run(req.run_id)
if not run:
raise AppException(404, "OPRO run not found", "RUN_NOT_FOUND")
if not run["test_cases"]:
raise AppException(400, "No test cases defined for this run", "NO_TEST_CASES")
# Evaluate the instruction
try:
score = evaluate_system_instruction(
system_instruction=req.instruction,
test_cases=run["test_cases"],
model_name=run["model_name"]
)
except Exception as e:
raise AppException(500, f"Evaluation failed: {e}", "EVALUATION_ERROR")
# Add to trajectory
add_opro_evaluation(req.run_id, req.instruction, score)
# Get updated run info
run = get_opro_run(req.run_id)
return ok({
"run_id": req.run_id,
"instruction": req.instruction,
"score": score,
"best_score": run["best_score"],
"is_new_best": score == run["best_score"] and score > 0
})
@app.get("/opro/runs", tags=["opro-true"])
def opro_list_runs():
"""
List all OPRO optimization runs.
"""
runs = list_opro_runs()
return ok({"runs": runs, "total": len(runs)})
@app.get("/opro/run/{run_id}", tags=["opro-true"])
def opro_get_run(run_id: str):
"""
Get detailed information about an OPRO run.
"""
run = get_opro_run(run_id)
if not run:
raise AppException(404, "OPRO run not found", "RUN_NOT_FOUND")
# Get sorted trajectory
trajectory = get_opro_trajectory(run_id)
return ok({
"run_id": run_id,
"task_description": run["task_description"],
"iteration": run["iteration"],
"status": run["status"],
"best_score": run["best_score"],
"best_instruction": run["best_instruction"],
"num_test_cases": len(run["test_cases"]),
"test_cases": [{"input": tc[0], "expected_output": tc[1]} for tc in run["test_cases"]],
"trajectory": [{"instruction": inst, "score": score} for inst, score in trajectory[:10]], # Top 10
"current_candidates": run["current_candidates"]
})
@app.post("/opro/test_cases", tags=["opro-true"])
def opro_add_test_cases(req: OPROAddTestCasesReq):
"""
Add or update test cases for an OPRO run.
"""
run = get_opro_run(req.run_id)
if not run:
raise AppException(404, "OPRO run not found", "RUN_NOT_FOUND")
# Convert test cases
test_cases = [(tc.input, tc.expected_output) for tc in req.test_cases]
# Update test cases
set_opro_test_cases(req.run_id, test_cases)
return ok({
"run_id": req.run_id,
"num_test_cases": len(test_cases),
"test_cases": [{"input": tc[0], "expected_output": tc[1]} for tc in test_cases]
})
@app.post("/opro/generate_and_evaluate", tags=["opro-true"])
def opro_generate_and_evaluate(req: OPROGenerateAndEvaluateReq):
"""
Generate candidates and auto-evaluate them (for chat-like UX).
This is the main endpoint for the chat interface. It:
1. Generates candidates based on trajectory
2. Auto-evaluates them (if test cases exist and auto_evaluate=True)
3. Returns top-k sorted by score (or diversity if no evaluation)
"""
run = get_opro_run(req.run_id)
if not run:
raise AppException(404, "OPRO run not found", "RUN_NOT_FOUND")
top_k = req.top_k or config.TOP_K
pool_size = req.pool_size or config.GENERATION_POOL_SIZE
# Get trajectory for optimization
trajectory = get_opro_trajectory(req.run_id)
# Generate candidates
try:
candidates = generate_system_instruction_candidates(
task_description=run["task_description"],
trajectory=trajectory if trajectory else None,
top_k=pool_size, # Generate pool_size candidates first
pool_size=pool_size,
model_name=run["model_name"]
)
except Exception as e:
raise AppException(500, f"Failed to generate candidates: {e}", "GENERATION_ERROR")
# Decide whether to evaluate
should_evaluate = req.auto_evaluate and len(run["test_cases"]) > 0
if should_evaluate:
# Auto-evaluate all candidates
scored_candidates = []
for candidate in candidates:
try:
score = evaluate_system_instruction(
system_instruction=candidate,
test_cases=run["test_cases"],
model_name=run["model_name"]
)
scored_candidates.append({"instruction": candidate, "score": score})
# Add to trajectory
add_opro_evaluation(req.run_id, candidate, score)
except Exception as e:
# If evaluation fails, assign score 0
scored_candidates.append({"instruction": candidate, "score": 0.0})
# Sort by score (highest first)
scored_candidates.sort(key=lambda x: x["score"], reverse=True)
# Return top-k
top_candidates = scored_candidates[:top_k]
# Update iteration
update_opro_iteration(req.run_id, [c["instruction"] for c in top_candidates])
return ok({
"run_id": req.run_id,
"candidates": top_candidates,
"iteration": run["iteration"] + 1,
"evaluated": True,
"best_score": run["best_score"]
})
else:
# No evaluation - use diversity-based selection (already done by clustering)
# Just return the candidates without scores
top_candidates = [
{"instruction": candidate, "score": None}
for candidate in candidates[:top_k]
]
# Update iteration
update_opro_iteration(req.run_id, [c["instruction"] for c in top_candidates])
return ok({
"run_id": req.run_id,
"candidates": top_candidates,
"iteration": run["iteration"] + 1,
"evaluated": False,
"best_score": run["best_score"]
})
@app.post("/opro/execute", tags=["opro-true"])
def opro_execute(req: OPROExecuteReq):
"""
Execute a system instruction with user input.
This uses the selected instruction as a system prompt and calls the LLM.
"""
try:
# Construct full prompt with system instruction
full_prompt = f"{req.instruction}\n\n{req.user_input}"
# Call LLM
response = call_qwen(
full_prompt,
temperature=0.2,
max_tokens=1024,
model_name=req.model_name
)
return ok({
"instruction": req.instruction,
"user_input": req.user_input,
"response": response
})
except Exception as e:
raise AppException(500, f"Execution failed: {e}", "EXECUTION_ERROR")