LLM 요약 고도화하기

import fitz  # PyMuPDF
import requests
import weave
import weave
import os

# Initialize Weave for logging
weave.init('summarizer')

ENDPOINT_URL = "https://Mistral-small-achqr.eastus2.models.ai.azure.com/chat/completions"
PRIMARY_KEY = "your key"
DEFAULT_PAPER_URL = "https://arxiv.org/pdf/2407.20183.pdf"
IN_CONTEXT_FILE = "in_context_example.txt"

summary_length = 400  # Set the desired maximum length of the summary in words

FIXED_QUESTIONS = """
What is the primary objective of this research?
What methodologies or algorithms are proposed or evaluated?
What datasets or experimental setups are used in this study?
What are the key findings and contributions of this research?
What are the implications of these findings for the broader field of AI?
What limitations or challenges are acknowledged by the authors?
What are the proposed future directions or next steps in this research?
"""



@weave.op()
def get_model_prediction(prompt):
    headers = {
        "Authorization": f"Bearer {PRIMARY_KEY}",
        "Content-Type": "application/json"
    }

    payload = {
        "messages": [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": prompt}
        ]
    }

    response = requests.post(ENDPOINT_URL, headers=headers, json=payload)
    return response.json()

def download_pdf(url, filename):
    response = requests.get(url)
    with open(filename, 'wb') as file:
        file.write(response.content)
    print(f"Downloaded PDF from {url}")

def load_pdf_text(pdf_path):
    doc = fitz.open(pdf_path)
    text = ""
    for page_num in range(len(doc)):
        page = doc.load_page(page_num)
        text += page.get_text()
    return text

def load_in_context_example(filepath):
    if os.path.exists(filepath):
        with open(filepath, 'r') as file:
            return file.read()
    return ""

if __name__ == "__main__":
    # Download the PDF if it doesn't exist
    pdf_path = "2407.20183.pdf"
    if not os.path.exists(pdf_path):
        download_pdf(DEFAULT_PAPER_URL, pdf_path)

    # Load the PDF text
    pdf_text = load_pdf_text(pdf_path)
    print("PDF text loaded.")

    # Load the in-context example
    in_context_example = load_in_context_example(IN_CONTEXT_FILE)
    
    # Combine the in-context example with the fixed questions
    prompt = (
            f"Heres a previous In-context example paper summary:\n{in_context_example}\n\n"
            f"Please summarize the following text and address these questions:\n{FIXED_QUESTIONS} in {summary_length} words \n\n"
            f"Text:\n{pdf_text}"
        )
    # Get the model prediction
    response = get_model_prediction(prompt)
    print("Model response:", response)


import fitz  
import requests
import os
import weave  # Import Weave for logging and tracking

# Initialize Weave for logging
weave.init('summarizer')

ENDPOINT_URL = "https://Mistral-small-achqr.eastus2.models.ai.azure.com/chat/completions"
PRIMARY_KEY = "your key"
DEFAULT_PAPER_URL = "https://arxiv.org/pdf/2407.20183.pdf"
IN_CONTEXT_FILE = "in_context_example.txt"

summary_length = 400  # Set the desired maximum length of the summary in words

FIXED_QUESTIONS = """
What is the primary objective of this research?
What methodologies or algorithms are proposed or evaluated?
What datasets or experimental setups are used in this study?
What are the key findings and contributions of this research?
What are the implications of these findings for the broader field of AI?
What limitations or challenges are acknowledged by the authors?
What are the proposed future directions or next steps in this research?
"""

@weave.op()
def get_model_prediction(prompt):
    headers = {
        "Authorization": f"Bearer {PRIMARY_KEY}",
        "Content-Type": "application/json"
    }

    payload = {
        "messages": [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": prompt}
        ]
    }

    response = requests.post(ENDPOINT_URL, headers=headers, json=payload)
    return response.json()

def download_pdf(url, filename):
    response = requests.get(url)
    with open(filename, 'wb') as file:
        file.write(response.content)
    print(f"Downloaded PDF from {url}")

def load_pdf_text(pdf_path):
    doc = fitz.open(pdf_path)
    text = ""
    for page_num in range(len(doc)):
        page = doc.load_page(page_num)
        text += page.get_text()
    return text

def load_in_context_example(filepath):
    if os.path.exists(filepath):
        with open(filepath, 'r') as file:
            return file.read()
    return ""

if __name__ == "__main__":
    # Download the PDF if it doesn't exist
    pdf_path = "2407.20183.pdf"
    if not os.path.exists(pdf_path):
        download_pdf(DEFAULT_PAPER_URL, pdf_path)

    # Load the PDF text
    pdf_text = load_pdf_text(pdf_path)
    print("PDF text loaded.")

    # Load the in-context example
    in_context_example = load_in_context_example(IN_CONTEXT_FILE)

    # Generate dynamic questions
    prompt_for_questions = f"Generate key questions that a researcher would ask based on the following text:\n{pdf_text}"
    questions_response = get_model_prediction(prompt_for_questions)

    if questions_response:
        generated_questions = questions_response.get("choices")[0].get("message").get("content")
        print("Generated Questions:")
        print(generated_questions)

        # Combine fixed and generated questions to create the final prompt
        final_prompt = (
            f"Heres a previous In-context example paper summary:\n{in_context_example}\n\n"
            f"Please summarize the following text and address these questions:\n{FIXED_QUESTIONS}\n{generated_questions} in {summary_length} words \n\n"
            f"Text:\n{pdf_text}"
        )

        # Get the final model prediction
        final_response = get_model_prediction(final_prompt)
        print("Model response:", final_response)

import fitz  # PyMuPDF
import requests
import weave
import os

# Initialize Weave for logging
weave.init('summarizer')


ENDPOINT_URL = "https://Mistral-small-achqr.eastus2.models.ai.azure.com/chat/completions"
PRIMARY_KEY = "your key"
DEFAULT_PAPER_URL = "https://arxiv.org/pdf/2407.20183.pdf"
IN_CONTEXT_FILE = "in_context_example.txt"

summary_length = 400  # Set the desired maximum length of the summary in words
chunk_size = 800  # Example chunk size in words
summary_pct = 10   # Example summary percentage for chunked summarization

FIXED_QUESTIONS = """
What is the primary objective of this research?
What methodologies or algorithms are proposed or evaluated?
What datasets or experimental setups are used in this study?
What are the key findings and contributions of this research?
What are the implications of these findings for the broader field of AI?
What limitations or challenges are acknowledged by the authors?
What are the proposed future directions or next steps in this research?
"""


@weave.op()
def get_model_prediction(prompt):
    headers = {
        "Authorization": f"Bearer {PRIMARY_KEY}",
        "Content-Type": "application/json"
    }

    payload = {
        "messages": [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": prompt}
        ]
    }

    response = requests.post(ENDPOINT_URL, headers=headers, json=payload)
    return response.json()

def download_pdf(url, filename):
    response = requests.get(url)
    with open(filename, 'wb') as file:
        file.write(response.content)
    print(f"Downloaded PDF from {url}")

def load_pdf_text(pdf_path):
    doc = fitz.open(pdf_path)
    text = ""
    for page_num in range(len(doc)):
        page = doc.load_page(page_num)
        text += page.get_text()
    return text

def load_in_context_example(filepath):
    if os.path.exists(filepath):
        with open(filepath, 'r') as file:
            return file.read()
    return ""

def chunk_text_by_words(text, chunk_size):
    words = text.split()
    return [' '.join(words[i:i + chunk_size]) for i in range(0, len(words), chunk_size)]

def calculate_summary_length(chunk_text, summary_pct):
    word_count = len(chunk_text.split())
    return max(1, int(word_count * summary_pct / 100))

if __name__ == "__main__":
    # Download the PDF if it doesn't exist
    pdf_path = "2407.20183.pdf"
    if not os.path.exists(pdf_path):
        download_pdf(DEFAULT_PAPER_URL, pdf_path)

    # Load the PDF text
    pdf_text = load_pdf_text(pdf_path)
    print("PDF text loaded.")

    # Load the in-context example
    in_context_example = load_in_context_example(IN_CONTEXT_FILE)

    # Chunked Summarization
    chunks = chunk_text_by_words(pdf_text, chunk_size)
    chunk_summaries = []

    for i, chunk in enumerate(chunks):
        print(f"Processing chunk {i+1}/{len(chunks)}")

        # Calculate the dynamic summary length based on the chunk size
        summary_len = calculate_summary_length(chunk, summary_pct)

        prompt = (
            f"Summarize the following section of a research paper in {summary_len} words):\n{chunk}"
        )
        response = get_model_prediction(prompt)
        chunk_summaries.append(response.get("choices")[0].get("message").get("content"))

    # Combine chunk summaries and generate dynamic questions
    combined_summary = " ".join(chunk_summaries)
    prompt_for_questions = (
        f"In-context example:\n{in_context_example}\n\n"
        f"Generate a few key questions a researcher might ask about the following summarized sections:\n{combined_summary}"
    )
    questions_response = get_model_prediction(prompt_for_questions)

    if questions_response:
        generated_questions = questions_response.get("choices")[0].get("message").get("content")
        print("Generated Questions:")
        print(generated_questions)

        # Use the combined summary and generated questions to create the final prompt
        final_prompt = (
            f"In-context example:\n{in_context_example}\n\n"
            f"Please summarize the following text and address these questions :\n{FIXED_QUESTIONS}\n{generated_questions} (Word Limit: {summary_length} words)\n\n"
            f"Text:\n{combined_summary}"
        )

        # Get the final model prediction
        final_response = get_model_prediction(final_prompt)
        print("Model response:", final_response)


import requests
import json
import random
import os
from flask import Flask, request, jsonify, render_template
import weave

# Initialize Weave
client = weave.init('summarizer')

app = Flask(__name__)

# Define global variables for the models and cache
MODELS = [
    {"endpoint": "https://Meta-Llama-3-1-405B-Instruct-lqf.eastus2.models.ai.azure.com/chat/completions", "key": "your key"},
    {"endpoint": "https://Meta-Llama-3-1-70B-Instruct-xwib.eastus2.models.ai.azure.com/chat/completions", "key": "your key"},
    # {"endpoint": "your fourth model endpoint url", "key": "your fourth model key"},
    # {"endpoint": "your fifth model endpoint url", "key": "your fifth model key"},
]

IN_CONTEXT_FILE = "./in_context_example.txt"
SUMMARY_LENGTH = 400  # Maximum length of the summary in words
FIXED_QUESTIONS = """
What is the primary objective of this research?
What methodologies or algorithms are proposed or evaluated?
What datasets or experimental setups are used in this study?
What are the key findings and contributions of this research?
What are the implications of these findings for the broader field of AI?
What limitations or challenges are acknowledged by the authors?
What are the proposed future directions or next steps in this research?
"""

# Cache to store used prompts and models
used_prompts_cache = {}

@weave.op()
def get_model_prediction(prompt, endpoint, key, original_input=None):
    headers = {
        "Authorization": f"Bearer {key}",
        "Content-Type": "application/json"
    }

    payload = {
        "messages": [
            {"role": "system", "content": "You are a summarization assistant."},
            {"role": "user", "content": prompt}
        ]
    }

    response = requests.post(endpoint, headers=headers, json=payload)

    # Get the current call ID
    current_call = weave.get_current_call()
    call_id = current_call.id

    try:
        return parse_response(response.json()), call_id
    except json.JSONDecodeError as e:
        print(f"Failed to decode JSON response: {e}")
        return None, call_id

def parse_response(response):
    if 'choices' in response:
        choices = response['choices']
        for choice in choices:
            if 'message' in choice and 'content' in choice['message']:
                content = choice['message']['content']
                print(f"Model response content: {content}")
                return content
            if 'finish_reason' in choice:
                finish_reason = choice['finish_reason']
                print(f"Finish reason: {finish_reason}")
    return "No valid response"

def load_in_context_example(filepath):
    if os.path.exists(filepath):
        with open(filepath, 'r') as file:
            return file.read()
    return ""

@weave.op()
def perform_self_reflection(summary, original_text, endpoint, key, original_input=None):
    reflection_prompt = (
        f"The following is a summary of the original document.  "
        f"Original Document:\n{original_text}\n\n"
        f"Summary:\n{summary}\n\n"
        f"If there are mistakes, simply remove incorrect sections and REWRITE it COMPLETELY as it was originally with the only change being the removal of incorrect sentences:"
        f"If everything is correct, simply rewrite the summary EXACTLY as it was:"
    )

    revised_summary, _ = get_model_prediction(reflection_prompt, endpoint, key)
    return revised_summary

def select_random_model(prompt):
    available_models = [model for model in MODELS if prompt not in used_prompts_cache.get(model['endpoint'], [])]

    if not available_models:
        # If all models have been used, reset the cache for the prompt
        for model in MODELS:
            if model['endpoint'] in used_prompts_cache:
                used_prompts_cache[model['endpoint']].remove(prompt)
        available_models = MODELS

    selected_model = random.choice(available_models)

    # Cache the selected model for the prompt
    if selected_model['endpoint'] not in used_prompts_cache:
        used_prompts_cache[selected_model['endpoint']] = []
    used_prompts_cache[selected_model['endpoint']].append(prompt)

    return selected_model

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    prompt = data['prompt']

    # Load the in-context example
    in_context_example = load_in_context_example(IN_CONTEXT_FILE)

    # Select a random model that hasn't been used with this prompt yet
    model = select_random_model(prompt)

    # Generate dynamic questions based on the input text
    prompt_for_questions = f"Generate key questions that a researcher would ask based on the following text:\n{prompt}"
    questions_response, _ = get_model_prediction(prompt_for_questions, model['endpoint'], model['key'])

    generated_questions = ""
    if questions_response:
        generated_questions = questions_response
    # Combine fixed and generated questions to create the final prompt
    final_prompt = (
        f"Heres a previous In-context example paper summary:\n{in_context_example}\n\n"
        f"Please summarize the following text and address these questions:\n{FIXED_QUESTIONS}\n{generated_questions} in {SUMMARY_LENGTH} words.\n\n"
        f"Text:\n{prompt}"
    )

    # Get the initial summary and call ID from the selected model
    summary, call_id = get_model_prediction(final_prompt, model['endpoint'], model['key'], original_input=prompt)

    # Perform self-reflection to remove factual errors
    revised_summary = perform_self_reflection(summary, prompt, model['endpoint'], model['key'], original_input=prompt)
    # revised_summary = summary
    return jsonify({
        "response": revised_summary, 
        "call_id": call_id, 
        "model_used": model['endpoint']
    })

@app.route('/feedback', methods=['POST'])
def feedback():
    data = request.json
    call_id = data['call_id']
    feedback_type = data['feedback']

    if feedback_type == "upvote":
        client.call(call_id).feedback.add_reaction("👍")
    elif feedback_type == "downvote":
        client.call(call_id).feedback.add_reaction("👎")

    return jsonify({"status": "success"})

if __name__ == "__main__":
    app.run(debug=True)



current_call = weave.get_current_call()
call_id = current_call.id

@app.route('/feedback', methods=['POST'])
def feedback():
    data = request.json
    call_id = data['call_id']
    feedback_type = data['feedback']

    if feedback_type == "upvote":
        client.call(call_id).feedback.add_reaction("👍")
    elif feedback_type == "downvote":
        client.call(call_id).feedback.add_reaction("👎")

    return jsonify({"status": "success"})

def perform_self_reflection(summary, original_text, endpoint, key):
    reflection_prompt = (
        f"The following is a summary of the original document. Identify and remove any factual errors "
        f"from the summary, and rewrite it to be accurate:\n\n"
        f"Original Document:\n{original_text}\n\n"
        f"Summary:\n{summary}\n\n"
        f"Revised Summary:"
    )

    revised_summary, _ = get_model_prediction(reflection_prompt, endpoint, key)
    return revised_summary