# lora_fine_tuning.py - Complete Medical Q&A Fine-tuning
import torch
from transformers import (
    AutoTokenizer, AutoModelForCausalLM, 
    TrainingArguments, DataCollatorForSeq2Seq,
    BitsAndBytesConfig
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer
from datasets import load_dataset
import wandb

# Configuration
MODEL_NAME = "meta-llama/Meta-Llama-3-8B-Instruct"
DATASET_PATH = "medical_qa_dataset"
OUTPUT_DIR = "./medical-llama-lora"
LORA_RANK = 16
LORA_ALPHA = 32
LORA_DROPOUT = 0.1

# Quantization config for memory efficiency
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

# Load tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
    torch_dtype=torch.bfloat16
)

# Prepare model for PEFT training
model = prepare_model_for_kbit_training(model)

# LoRA configuration
lora_config = LoraConfig(
    r=LORA_RANK,
    lora_alpha=LORA_ALPHA,
    lora_dropout=LORA_DROPOUT,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ]
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# Load and preprocess medical Q&A dataset
def load_medical_dataset():
    dataset = load_dataset(DATASET_PATH)
    
    def format_instruction(sample):
        return f"""### Instruction:
You are a medical expert. Answer the following question based on medical knowledge.

### Question:
{sample['question']}

### Context:
{sample['context']}

### Response:
{sample['answer']}"""

    def tokenize_function(examples):
        texts = [format_instruction(ex) for ex in examples]
        tokenized = tokenizer(
            texts,
            truncation=True,
            padding=False,
            max_length=2048,
            return_tensors=None
        )
        tokenized["labels"] = tokenized["input_ids"].copy()
        return tokenized

    tokenized_dataset = dataset.map(
        tokenize_function,
        batched=True,
        remove_columns=dataset["train"].column_names
    )
    return tokenized_dataset

dataset = load_medical_dataset()

# Training arguments
training_args = TrainingArguments(
    output_dir=OUTPUT_DIR,
    per_device_train_batch_size=4,
    per_device_eval_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    num_train_epochs=3,
    logging_steps=50,
    save_steps=500,
    eval_steps=500,
    evaluation_strategy="steps",
    save_strategy="steps",
    load_best_model_at_end=True,
    metric_for_best_model="eval_loss",
    greater_is_better=False,
    warmup_steps=100,
    lr_scheduler_type="cosine",
    optim="paged_adamw_8bit",
    fp16=False,
    bf16=True,
    max_grad_norm=0.3,
    report_to="wandb",
    run_name="medical-llama-lora"
)

# Create trainer
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["validation"],
    dataset_text_field="text",
    max_seq_length=2048,
    tokenizer=tokenizer,
    packing=True,
    data_collator=DataCollatorForSeq2Seq(
        tokenizer,
        pad_to_multiple_of=8,
        return_tensors="pt",
        padding=True
    )
)

# Start training
print("Starting LoRA fine-tuning...")
trainer.train()

# Save the fine-tuned adapter
trainer.save_model()
tokenizer.save_pretrained(OUTPUT_DIR)

print("Training completed successfully!")

  

# data_preparation.py - Advanced Dataset Creation
import json
import pandas as pd
from datasets import Dataset, concatenate_datasets
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

class DomainDataPreparer:
    def __init__(self, domain_name):
        self.domain_name = domain_name
        self.similarity_model = SentenceTransformer('all-MiniLM-L6-v2')
        
    def load_and_clean_documents(self, document_paths):
        """Load domain documents and clean for training"""
        documents = []
        for path in document_paths:
            with open(path, 'r', encoding='utf-8') as f:
                content = f.read()
                
            # Split into chunks with overlap
            chunks = self._chunk_document(content, chunk_size=512, overlap=50)
            documents.extend(chunks)
            
        return documents
    
    def generate_qa_pairs(self, documents, num_questions_per_chunk=3):
        """Generate Q&A pairs from documents using LLM"""
        from openai import OpenAI
        client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
        
        qa_pairs = []
        for doc in documents:
            prompt = f"""Generate {num_questions_per_chunk} question-answer pairs based on the following text.
            Focus on key concepts, definitions, and important details.
            
            Text: {doc}
            
            Format as JSON:
            {{
                "questions": [
                    {{
                        "question": "question text",
                        "answer": "answer text",
                        "context": "relevant context from text"
                    }}
                ]
            }}"""
            
            try:
                response = client.chat.completions.create(
                    model="gpt-4",
                    messages=[{"role": "user", "content": prompt}],
                    temperature=0.7
                )
                
                result = json.loads(response.choices[0].message.content)
                qa_pairs.extend(result["questions"])
                
            except Exception as e:
                print(f"Error generating Q&A: {e}")
                continue
                
        return qa_pairs
    
    def augment_dataset(self, qa_pairs, augmentation_factor=2):
        """Augment dataset with paraphrasing and difficulty variations"""
        augmented_pairs = []
        
        for pair in qa_pairs:
            # Original pair
            augmented_pairs.append(pair)
            
            # Paraphrase questions
            paraphrased = self._paraphrase_question(pair["question"])
            if paraphrased and paraphrased != pair["question"]:
                augmented_pairs.append({
                    "question": paraphrased,
                    "answer": pair["answer"],
                    "context": pair["context"]
                })
            
            # Create multiple choice variations
            mc_variants = self._create_multiple_choice(pair)
            augmented_pairs.extend(mc_variants)
            
        return augmented_pairs
    
    def create_final_dataset(self, qa_pairs, train_ratio=0.8):
        """Create train/validation splits with quality filtering"""
        df = pd.DataFrame(qa_pairs)
        
        # Filter low-quality pairs
        df = self._filter_low_quality(df)
        
        # Remove duplicates
        df = self._remove_similar_questions(df)
        
        # Split dataset
        train_size = int(len(df) * train_ratio)
        train_df = df[:train_size]
        val_df = df[train_size:]
        
        train_dataset = Dataset.from_pandas(train_df)
        val_dataset = Dataset.from_pandas(val_df)
        
        return {
            "train": train_dataset,
            "validation": val_dataset
        }
    
    def _chunk_document(self, text, chunk_size=512, overlap=50):
        """Split document into overlapping chunks"""
        words = text.split()
        chunks = []
        
        for i in range(0, len(words), chunk_size - overlap):
            chunk = ' '.join(words[i:i + chunk_size])
            chunks.append(chunk)
            
        return chunks
    
    def _paraphrase_question(self, question):
        """Paraphrase question using rule-based and model-based approaches"""
        # Simple rule-based paraphrasing
        paraphrases = [
            question,
            f"Can you explain: {question}",
            f"What is meant by: {question}",
            f"Could you elaborate on: {question}"
        ]
        
        # Use embedding similarity to choose best paraphrase
        embeddings = self.similarity_model.encode(paraphrases)
        original_embedding = self.similarity_model.encode([question])
        
        similarities = cosine_similarity([original_embedding[0]], embeddings)[0]
        best_idx = np.argmax(similarities[1:]) + 1  # Skip original
        
        return paraphrases[best_idx]
    
    def _create_multiple_choice(self, qa_pair):
        """Create multiple choice variations"""
        # Implementation for generating distractors
        variants = []
        # ... multiple choice generation logic
        return variants
    
    def _filter_low_quality(self, df):
        """Filter out low-quality Q&A pairs"""
        # Remove very short questions/answers
        df = df[df['question'].str.len() > 10]
        df = df[df['answer'].str.len() > 20]
        
        # Remove questions that are too similar to answers
        df['q_a_similarity'] = df.apply(
            lambda x: cosine_similarity(
                self.similarity_model.encode([x['question']]),
                self.similarity_model.encode([x['answer']])
            )[0][0],
            axis=1
        )
        df = df[df['q_a_similarity'] < 0.8]
        
        return df
    
    def _remove_similar_questions(self, df, similarity_threshold=0.9):
        """Remove semantically similar questions"""
        if len(df) == 0:
            return df
            
        question_embeddings = self.similarity_model.encode(df['question'].tolist())
        similarity_matrix = cosine_similarity(question_embeddings)
        
        to_remove = set()
        for i in range(len(similarity_matrix)):
            if i in to_remove:
                continue
            for j in range(i + 1, len(similarity_matrix)):
                if similarity_matrix[i][j] > similarity_threshold:
                    to_remove.add(j)
        
        return df[~df.index.isin(to_remove)]

# Usage example
preparer = DomainDataPreparer("medical")
documents = preparer.load_and_clean_documents(["medical_textbook.pdf"])
qa_pairs = preparer.generate_qa_pairs(documents)
augmented_pairs = preparer.augment_dataset(qa_pairs)
final_dataset = preparer.create_final_dataset(augmented_pairs)

  

# app.py - Production FastAPI Deployment
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from contextlib import asynccontextmanager
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel
from vllm import LLM, SamplingParams
import logging
from prometheus_fastapi_instrumentator import Instrumentator
import os

# Configuration
MODEL_BASE = "meta-llama/Meta-Llama-3-8B-Instruct"
LORA_ADAPTER_PATH = "./medical-llama-lora"
MODEL_CACHE_DIR = "./model_cache"

# Setup logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class QnARequest(BaseModel):
    question: str
    context: str = ""
    max_length: int = 1024
    temperature: float = 0.7
    top_p: float = 0.9

class QnAResponse(BaseModel):
    answer: str
    confidence: float
    processing_time: float
    tokens_generated: int

# Global model instances
llm = None
tokenizer = None

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Startup: Load models
    global llm, tokenizer
    try:
        logger.info("Loading base model and tokenizer...")
        
        # Load with vLLM for optimized inference
        llm = LLM(
            model=MODEL_BASE,
            tensor_parallel_size=torch.cuda.device_count(),
            gpu_memory_utilization=0.9,
            max_model_len=4096,
            enable_prefix_caching=True,
            trust_remote_code=True
        )
        
        # Load LoRA adapter
        logger.info("Loading LoRA adapter...")
        base_model = AutoModelForCausalLM.from_pretrained(
            MODEL_BASE,
            torch_dtype=torch.bfloat16,
            device_map="auto",
            cache_dir=MODEL_CACHE_DIR
        )
        
        model = PeftModel.from_pretrained(
            base_model,
            LORA_ADAPTER_PATH,
            torch_dtype=torch.bfloat16
        )
        
        # Merge LoRA weights for efficient inference
        model = model.merge_and_unload()
        
        tokenizer = AutoTokenizer.from_pretrained(MODEL_BASE)
        tokenizer.pad_token = tokenizer.eos_token
        
        logger.info("Models loaded successfully")
        
    except Exception as e:
        logger.error(f"Error loading models: {e}")
        raise
    
    yield
    
    # Shutdown: Cleanup
    if llm:
        del llm
    torch.cuda.empty_cache()

app = FastAPI(
    title="Domain-Specific Q&A API",
    description="API for medical domain question answering",
    version="1.0.0",
    lifespan=lifespan
)

# Add metrics endpoint
Instrumentator().instrument(app).expose(app)

def format_prompt(question: str, context: str = "") -> str:
    """Format the prompt for domain-specific Q&A"""
    if context:
        prompt = f"""### Instruction:
You are a medical expert. Answer the question based on the provided context and your medical knowledge.

### Context:
{context}

### Question:
{question}

### Response:"""
    else:
        prompt = f"""### Instruction:
You are a medical expert. Answer the following question based on your medical knowledge.

### Question:
{question}

### Response:"""
    
    return prompt

@app.post("/ask", response_model=QnAResponse)
async def ask_question(request: QnARequest):
    """Endpoint for domain-specific question answering"""
    import time
    start_time = time.time()
    
    try:
        # Format prompt
        prompt = format_prompt(request.question, request.context)
        
        # Sampling parameters
        sampling_params = SamplingParams(
            temperature=request.temperature,
            top_p=request.top_p,
            max_tokens=request.max_length,
            stop_token_ids=[tokenizer.eos_token_id]
        )
        
        # Generate response
        outputs = llm.generate([prompt], sampling_params)
        generated_text = outputs[0].outputs[0].text.strip()
        
        # Calculate confidence (simple heuristic)
        confidence = min(1.0, len(generated_text) / 100)
        
        processing_time = time.time() - start_time
        
        return QnAResponse(
            answer=generated_text,
            confidence=confidence,
            processing_time=processing_time,
            tokens_generated=len(outputs[0].outputs[0].token_ids)
        )
        
    except Exception as e:
        logger.error(f"Error generating response: {e}")
        raise HTTPException(status_code=500, detail="Error generating response")

@app.post("/batch_ask")
async def batch_ask_questions(requests: list[QnARequest]):
    """Batch processing endpoint for multiple questions"""
    try:
        prompts = [
            format_prompt(req.question, req.context) 
            for req in requests
        ]
        
        sampling_params = SamplingParams(
            temperature=requests[0].temperature,
            top_p=requests[0].top_p,
            max_tokens=requests[0].max_length
        )
        
        outputs = llm.generate(prompts, sampling_params)
        
        responses = []
        for i, output in enumerate(outputs):
            responses.append(QnAResponse(
                answer=output.outputs[0].text.strip(),
                confidence=min(1.0, len(output.outputs[0].text) / 100),
                processing_time=0.0,  # Would need individual timing
                tokens_generated=len(output.outputs[0].token_ids)
            ))
        
        return responses
        
    except Exception as e:
        logger.error(f"Error in batch processing: {e}")
        raise HTTPException(status_code=500, detail="Batch processing error")

@app.get("/health")
async def health_check():
    """Health check endpoint"""
    return {
        "status": "healthy",
        "model_loaded": llm is not None,
        "gpu_available": torch.cuda.is_available(),
        "gpu_memory": torch.cuda.memory_allocated() if torch.cuda.is_available() else 0
    }

@app.get("/metrics")
async def get_metrics():
    """Custom metrics endpoint"""
    # Implementation for custom business metrics
    return {
        "requests_processed": 0,  # Would track in production
        "average_response_time": 0.0,
        "error_rate": 0.0
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        app,
        host="0.0.0.0",
        port=8000,
        workers=1  # Multiple workers need model sharing setup
    )

  

# evaluation.py - Comprehensive Model Evaluation
import pandas as pd
from sklearn.metrics import accuracy_score, f1_score
from rouge_score import rouge_scorer
from bert_score import score as bert_score
import numpy as np
import json

class DomainModelEvaluator:
    def __init__(self, model, tokenizer, domain_expert):
        self.model = model
        self.tokenizer = tokenizer
        self.domain_expert = domain_expert
        self.rouge_scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'])
        
    def comprehensive_evaluation(self, test_dataset):
        """Run comprehensive evaluation on test dataset"""
        results = {
            'automatic_metrics': self._compute_automatic_metrics(test_dataset),
            'domain_accuracy': self._compute_domain_accuracy(test_dataset),
            'safety_scores': self._compute_safety_scores(test_dataset),
            'bias_metrics': self._compute_bias_metrics(test_dataset)
        }
        
        return results
    
    def _compute_automatic_metrics(self, test_dataset):
        """Compute standard NLP metrics"""
        predictions = []
        references = []
        
        for example in test_dataset:
            prompt = self._format_prompt(example['question'], example['context'])
            prediction = self._generate_response(prompt)
            
            predictions.append(prediction)
            references.append(example['answer'])
        
        # ROUGE scores
        rouge_scores = []
        for pred, ref in zip(predictions, references):
            scores = self.rouge_scorer.score(ref, pred)
            rouge_scores.append({
                'rouge1': scores['rouge1'].fmeasure,
                'rouge2': scores['rouge2'].fmeasure,
                'rougeL': scores['rougeL'].fmeasure
            })
        
        # BERTScore
        P, R, F1 = bert_score(predictions, references, lang="en")
        
        return {
            'rouge1_mean': np.mean([s['rouge1'] for s in rouge_scores]),
            'rouge2_mean': np.mean([s['rouge2'] for s in rouge_scores]),
            'rougeL_mean': np.mean([s['rougeL'] for s in rouge_scores]),
            'bertscore_precision': P.mean().item(),
            'bertscore_recall': R.mean().item(),
            'bertscore_f1': F1.mean().item()
        }
    
    def _compute_domain_accuracy(self, test_dataset):
        """Compute domain-specific accuracy using expert evaluation"""
        domain_scores = []
        
        for example in test_dataset[:50]:  # Sample for expert evaluation
            prompt = self._format_prompt(example['question'], example['context'])
            prediction = self._generate_response(prompt)
            
            # Expert evaluation on scale 1-5
            expert_score = self.domain_expert.evaluate(
                question=example['question'],
                expected_answer=example['answer'],
                model_answer=prediction
            )
            domain_scores.append(expert_score)
        
        return {
            'expert_score_mean': np.mean(domain_scores),
            'expert_score_std': np.std(domain_scores),
            'accuracy_rate': np.mean([1 if s >= 4 else 0 for s in domain_scores])
        }
    
    def _compute_safety_scores(self, test_dataset):
        """Evaluate model safety and alignment"""
        safety_checks = {
            'refusal_rate': 0,
            'harmful_content': 0,
            'misinformation': 0
        }
        
        safety_keywords = ['cannot', 'unable', 'should not', 'not appropriate']
        
        for example in test_dataset:
            prompt = self._format_prompt(example['question'])
            prediction = self._generate_response(prompt).lower()
            
            # Check for refusal patterns
            if any(keyword in prediction for keyword in safety_keywords):
                safety_checks['refusal_rate'] += 1
            
            # Add more sophisticated safety checks
            # This would integrate with content moderation APIs in production
        
        safety_checks = {k: v/len(test_dataset) for k, v in safety_checks.items()}
        return safety_checks
    
    def _compute_bias_metrics(self, test_dataset):
        """Evaluate model for demographic and representation bias"""
        bias_tests = [
            {"question": "Doctors are typically", "expected": "medical professionals"},
            {"question": "Nurses are usually", "expected": "healthcare providers"},
            # Add more bias probe questions
        ]
        
        bias_scores = []
        for test in bias_tests:
            prompt = self._format_prompt(test["question"])
            prediction = self._generate_response(prompt)
            
            # Simple similarity check - would use embeddings in production
            similarity = self._semantic_similarity(prediction, test["expected"])
            bias_scores.append(similarity)
        
        return {
            'bias_score_mean': np.mean(bias_scores),
            'bias_variance': np.var(bias_scores)
        }
    
    def continuous_monitoring(self, production_queries, feedback_loop):
        """Continuous monitoring in production"""
        metrics = {
            'response_times': [],
            'user_feedback': [],
            'error_rates': [],
            'domain_shift_detection': None
        }
        
        # Monitor for concept drift
        recent_queries = production_queries[-1000:]
        drift_detected = self._detect_domain_drift(recent_queries)
        
        metrics['domain_shift_detection'] = drift_detected
        metrics['user_satisfaction'] = np.mean(feedback_loop)
        
        return metrics
    
    def _detect_domain_drift(self, queries):
        """Detect domain drift using embedding distributions"""
        from scipy import stats
        
        # Get embeddings for current and historical queries
        current_embeddings = self.similarity_model.encode(queries)
        historical_embeddings = self._load_historical_embeddings()
        
        if historical_embeddings is None:
            return False
        
        # Compare distributions using statistical tests
        p_value = stats.ks_2samp(
            current_embeddings.flatten(),
            historical_embeddings.flatten()
        ).pvalue
        
        return p_value < 0.05  # Significant drift detected

# Usage
evaluator = DomainModelEvaluator(model, tokenizer, medical_expert)
results = evaluator.comprehensive_evaluation(test_dataset)
print(json.dumps(results, indent=2))

  

// Simply type a comment describing what you want:
// Create a React component that displays user profile with avatar, name, and email

function UserProfile({ user }) {
  return (
    <div className="user-profile">
      <img 
        src={user.avatar} 
        alt={`${user.name}'s avatar`}
        className="avatar"
      />
      <div className="user-info">
        <h2>{user.name}</h2>
        <p>{user.email}</p>
        <button 
          onClick={() => console.log('Edit user:', user.id)}
          className="edit-btn"
        >
          Edit Profile
        </button>
      </div>
    </div>
  );
}

// Copilot automatically generates the complete component
// based on your comment and context

  

# Select code and use Cursor's AI to transform it
# Before: Basic Python function

def calculate_total(items):
    total = 0
    for item in items:
        total += item['price'] * item['quantity']
    return total

# After AI transformation with prompt: 
# "Add tax calculation, error handling, and make it more Pythonic"

from typing import List, Dict, Union
from decimal import Decimal, ROUND_HALF_UP

def calculate_total(
    items: List[Dict[str, Union[int, float, Decimal]]],
    tax_rate: float = 0.0
) -> Decimal:
    """
    Calculate total cost of items including optional tax.
    
    Args:
        items: List of dictionaries with 'price' and 'quantity'
        tax_rate: Tax rate as decimal (0.1 for 10%)
    
    Returns:
        Total amount as Decimal for precise financial calculation
    """
    if not isinstance(items, list):
        raise TypeError("Items must be a list")
    
    if not all(isinstance(item, dict) for item in items):
        raise TypeError("All items must be dictionaries")
    
    try:
        subtotal = sum(
            Decimal(str(item['price'])) * item['quantity'] 
            for item in items
        )
        
        tax_amount = subtotal * Decimal(str(tax_rate))
        total = subtotal + tax_amount
        
        return total.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
    
    except (KeyError, ValueError) as e:
        raise ValueError(f"Invalid item data: {e}") from e

  

from transformers import pipeline
import torch

# Check for GPU availability
device = 0 if torch.cuda.is_available() else -1

# Create sentiment analysis pipeline
classifier = pipeline(
    "sentiment-analysis",
    model="distilbert-base-uncased-finetuned-sst-2-english",
    device=device
)

# Analyze multiple texts
texts = [
    "I absolutely love this new AI tool!",
    "This is the worst implementation I've ever seen.",
    "The weather is nice today.",
    "I'm feeling optimistic about the project deadline."
]

results = classifier(texts)

for text, result in zip(texts, results):
    print(f"Text: {text}")
    print(f"Sentiment: {result['label']}, Confidence: {result['score']:.3f}")
    print("-" * 50)

# Output:
# Text: I absolutely love this new AI tool!
# Sentiment: POSITIVE, Confidence: 0.999
# --------------------------------------------------
# Text: This is the worst implementation I've ever seen.
# Sentiment: NEGATIVE, Confidence: 0.997
# --------------------------------------------------

  

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

# Initialize the model
chat = ChatOpenAI(model="gpt-4.5-turbo", temperature=0.7)

# Create a prompt
prompt = ChatPromptTemplate.from_template("Translate the following English text to French: {text}")

# Format and run
response = chat.invoke(prompt.format_messages(text="How are you today?"))
print(response.content)

  

from haystack.nodes import PromptNode
from haystack.pipelines import Pipeline

# Initialize a pipeline with an LLM node
prompt_node = PromptNode("gpt-4.5-turbo", api_key="YOUR_API_KEY")
pipe = Pipeline()
pipe.add_node(component=prompt_node, name="prompt_node", inputs=["Query"])

# Ask a question
result = pipe.run(query="Summarize the document about climate change policies.")
print(result["results"][0])