find_debates.py

"""
Find genuine debates using topic-stance extraction.

Step 1: Extract TOPIC + STANCE from each insight
Step 2: Group insights by topic
Step 3: Find opposing stances within topics

Usage:
    modal run insights_first/find_debates.py --input insights_first/data/modal_extraction_20260120_024600.json
"""

import modal
import json
import numpy as np
from datetime import datetime
from collections import defaultdict

app = modal.App("debate-finder")

MODEL_ID = "Qwen/Qwen2.5-7B-Instruct"
model_volume = modal.Volume.from_name("qwen-model-cache", create_if_missing=True)

vllm_image = (
    modal.Image.debian_slim(python_version="3.11")
    .pip_install("vllm>=0.6.0", "torch", "transformers", "huggingface_hub")
)

# Step 1: Extract topic and stance
EXTRACTION_PROMPT = """Extract the TOPIC and STANCE from this business insight.

TOPIC: The specific question or decision this insight addresses.
- Should be a question like "How to handle X?" or "Should you do Y?"
- Be specific, not vague categories

STANCE: The position this insight takes on that topic.
- What does it recommend or conclude?
- Be direct and specific

## Insight:
{insight}

## Respond with JSON only:
{{
  "topic": "The specific question/decision addressed (as a question)",
  "stance": "The position taken (direct statement)",
  "topic_category": "2-3 word category (e.g., 'hiring', 'product strategy', 'team management')"
}}"""

# Step 3: Check for genuine opposition
OPPOSITION_PROMPT = """Do these two insights take GENUINELY OPPOSITE positions on the same topic?

## Topic: {topic}

## Insight A stance: {stance_a}
Full insight: {insight_a}

## Insight B stance: {stance_b}
Full insight: {insight_b}

## Criteria for GENUINE OPPOSITION:
- They address the EXACT same decision/question
- They recommend OPPOSITE actions (not just different emphasis)
- A person couldn't follow both - they're mutually exclusive

## NOT opposition:
- Different aspects of same topic
- Complementary perspectives
- Different contexts where both could apply
- One is more specific than the other

## Respond with JSON:
{{
  "is_genuine_opposition": true/false,
  "opposition_quality": 1-10,
  "debate_question": "The question they disagree on (or null)",
  "side_a": "Position A in 5 words (or null)",
  "side_b": "Position B in 5 words (or null)", 
  "explanation": "Why this is or isn't genuine opposition"
}}

Quality 8-10: Clear "do X" vs "don't do X" on exact same decision
Quality 5-7: Tension but could coexist in some contexts
Quality 1-4: Different topics or complementary views"""


@app.cls(
    gpu="A10G",
    image=vllm_image,
    volumes={"/model-cache": model_volume},
    timeout=600,
    scaledown_window=300,
)
class DebateFinder:
    @modal.enter()
    def load_model(self):
        from vllm import LLM, SamplingParams
        
        self.llm = LLM(
            model=MODEL_ID,
            download_dir="/model-cache",
            trust_remote_code=True,
            max_model_len=4096,
            gpu_memory_utilization=0.9,
        )
        self.extract_params = SamplingParams(temperature=0.2, max_tokens=300)
        self.oppose_params = SamplingParams(temperature=0.2, max_tokens=400)
    
    @modal.method()
    def extract_topic_stance_batch(self, insights: list[tuple]) -> list[dict]:
        """Extract topic and stance from a batch of insights."""
        import re
        
        prompts = [EXTRACTION_PROMPT.format(insight=text) for text, idx in insights]
        outputs = self.llm.generate(prompts, self.extract_params)
        
        results = []
        for (text, idx), output in zip(insights, outputs):
            response = output.outputs[0].text.strip()
            try:
                json_match = re.search(r'\{[^{}]*\}', response, re.DOTALL)
                if json_match:
                    result = json.loads(json_match.group())
                else:
                    result = {"error": "No JSON", "raw": response[:200]}
            except:
                result = {"error": "Parse failed", "raw": response[:200]}
            
            result["idx"] = idx
            result["insight_text"] = text
            results.append(result)
        
        return results
    
    @modal.method()
    def check_opposition_batch(self, pairs: list[dict]) -> list[dict]:
        """Check if pairs of insights are genuinely opposed."""
        import re
        
        prompts = []
        for p in pairs:
            prompt = OPPOSITION_PROMPT.format(
                topic=p['topic'],
                stance_a=p['stance_a'],
                insight_a=p['insight_a'],
                stance_b=p['stance_b'],
                insight_b=p['insight_b']
            )
            prompts.append(prompt)
        
        outputs = self.llm.generate(prompts, self.oppose_params)
        
        results = []
        for p, output in zip(pairs, outputs):
            response = output.outputs[0].text.strip()
            try:
                json_match = re.search(r'\{[^{}]*\}', response, re.DOTALL)
                if json_match:
                    result = json.loads(json_match.group())
                else:
                    result = {"error": "No JSON"}
            except:
                result = {"error": "Parse failed"}
            
            result["idx_a"] = p['idx_a']
            result["idx_b"] = p['idx_b']
            result["topic"] = p['topic']
            result["insight_a"] = p['insight_a']
            result["insight_b"] = p['insight_b']
            result["stance_a"] = p['stance_a']
            result["stance_b"] = p['stance_b']
            results.append(result)
        
        return results


@app.local_entrypoint()
def main(input: str, topic_similarity: float = 0.7, min_quality: int = 7, batch_size: int = 50):
    """Find genuine debates through topic-stance extraction."""
    from sentence_transformers import SentenceTransformer
    from sklearn.metrics.pairwise import cosine_similarity
    
    # Load insights
    print(f"Loading insights from {input}...")
    with open(input, 'r', encoding='utf-8') as f:
        data = json.load(f)
    
    insights = [r['insight'] for r in data['results'] if r['has_insight'] and r['insight']]
    print(f"Loaded {len(insights)} insights")
    
    # Step 1: Extract topic + stance from all insights
    print(f"\n{'='*60}")
    print("STEP 1: Extracting topics and stances")
    print('='*60)
    
    finder = DebateFinder()
    
    insight_inputs = [(i['insight_text'], idx) for idx, i in enumerate(insights)]
    batches = [insight_inputs[i:i+batch_size] for i in range(0, len(insight_inputs), batch_size)]
    
    import time
    start = time.time()
    
    extracted = []
    for batch_results in finder.extract_topic_stance_batch.map(batches, order_outputs=False):
        extracted.extend(batch_results)
        print(f"  Progress: {len(extracted)}/{len(insights)} insights processed")
    
    print(f"Extraction complete in {time.time() - start:.1f}s")
    
    # Filter out errors
    valid_extracted = [e for e in extracted if 'topic' in e and 'stance' in e]
    print(f"Valid extractions: {len(valid_extracted)}/{len(extracted)}")
    
    # Step 2: Group by topic using embeddings
    print(f"\n{'='*60}")
    print("STEP 2: Grouping by topic similarity")
    print('='*60)
    
    print("Computing topic embeddings...")
    model = SentenceTransformer("all-MiniLM-L6-v2")
    topics = [e['topic'] for e in valid_extracted]
    topic_embeddings = model.encode(topics, show_progress_bar=True)
    
    # Find similar topic pairs
    print(f"Finding similar topics (threshold={topic_similarity})...")
    sim_matrix = cosine_similarity(topic_embeddings)
    
    # Group insights by similar topics
    topic_groups = defaultdict(list)
    used = set()
    
    for i in range(len(valid_extracted)):
        if i in used:
            continue
        
        group = [i]
        used.add(i)
        
        for j in range(i + 1, len(valid_extracted)):
            if j not in used and sim_matrix[i, j] >= topic_similarity:
                # Also check same episode exclusion
                if insights[valid_extracted[i]['idx']]['episode_title'] != insights[valid_extracted[j]['idx']]['episode_title']:
                    group.append(j)
                    used.add(j)
        
        if len(group) >= 2:
            topic_groups[valid_extracted[i]['topic']].extend(group)
    
    print(f"Found {len(topic_groups)} topic groups with 2+ insights")
    
    # Step 3: Check for opposition within groups
    print(f"\n{'='*60}")
    print("STEP 3: Finding opposing stances within topics")
    print('='*60)
    
    # Create pairs to check
    pairs_to_check = []
    for topic, indices in topic_groups.items():
        for i, idx_i in enumerate(indices):
            for idx_j in indices[i+1:]:
                e_i = valid_extracted[idx_i]
                e_j = valid_extracted[idx_j]
                
                pairs_to_check.append({
                    'topic': topic,
                    'idx_a': e_i['idx'],
                    'idx_b': e_j['idx'],
                    'stance_a': e_i['stance'],
                    'stance_b': e_j['stance'],
                    'insight_a': e_i['insight_text'],
                    'insight_b': e_j['insight_text'],
                })
    
    print(f"Checking {len(pairs_to_check)} potential debate pairs...")
    
    if len(pairs_to_check) == 0:
        print("No pairs to check. Try lowering topic_similarity threshold.")
        return
    
    # Batch check opposition
    pair_batches = [pairs_to_check[i:i+batch_size] for i in range(0, len(pairs_to_check), batch_size)]
    
    start = time.time()
    opposition_results = []
    for batch_results in finder.check_opposition_batch.map(pair_batches, order_outputs=False):
        opposition_results.extend(batch_results)
        debates_so_far = sum(1 for r in opposition_results if r.get('is_genuine_opposition') and r.get('opposition_quality', 0) >= min_quality)
        print(f"  Progress: {len(opposition_results)}/{len(pairs_to_check)} pairs, {debates_so_far} debates found")
    
    print(f"Opposition check complete in {time.time() - start:.1f}s")
    
    # Filter to genuine debates
    debates = [r for r in opposition_results 
               if r.get('is_genuine_opposition') and r.get('opposition_quality', 0) >= min_quality]
    debates = sorted(debates, key=lambda x: x.get('opposition_quality', 0), reverse=True)
    
    # Summary
    print(f"\n{'='*60}")
    print("DEBATE ANALYSIS RESULTS")
    print('='*60)
    print(f"Topic groups analyzed: {len(topic_groups)}")
    print(f"Pairs checked: {len(opposition_results)}")
    print(f"Genuine oppositions found: {sum(1 for r in opposition_results if r.get('is_genuine_opposition'))}")
    print(f"High-quality debates (>={min_quality}): {len(debates)}")
    
    # Show debates
    if debates:
        print(f"\n{'='*60}")
        print("GENUINE DEBATES DISCOVERED")
        print('='*60)
        
        for i, d in enumerate(debates[:15], 1):
            print(f"\n{i}. {d.get('debate_question', 'Untitled')} (Quality: {d.get('opposition_quality')}/10)")
            print(f"   Topic: {d['topic'][:60]}...")
            print(f"\n   SIDE A: {d.get('side_a', d['stance_a'][:50])}")
            print(f"   \"{d['insight_a'][:120]}...\"")
            print(f"\n   SIDE B: {d.get('side_b', d['stance_b'][:50])}")
            print(f"   \"{d['insight_b'][:120]}...\"")
            
            # Episode info
            ep_a = insights[d['idx_a']]['episode_title'][:35]
            ep_b = insights[d['idx_b']]['episode_title'][:35]
            print(f"\n   Episodes: '{ep_a}...' vs '{ep_b}...'")
    
    # Save results
    output = input.replace("modal_extraction_", "debates_")
    
    output_data = {
        'metadata': {
            'timestamp': datetime.now().isoformat(),
            'input_file': input,
            'topic_similarity_threshold': topic_similarity,
            'min_quality': min_quality,
            'total_insights': len(insights),
            'valid_extractions': len(valid_extracted),
            'topic_groups': len(topic_groups),
            'pairs_checked': len(opposition_results),
            'debates_found': len(debates),
        },
        'debates': debates,
        'topic_extractions': valid_extracted,
        'all_opposition_checks': opposition_results,
    }
    
    with open(output, 'w', encoding='utf-8') as f:
        json.dump(output_data, f, indent=2, ensure_ascii=False)
    
    print(f"\nResults saved to: {output}")