# Temperature 引數調整範例
import openai

response = openai.Completion.create(
    model="gpt-3.5-turbo",
    prompt="提供三種解決此問題的方法",
    temperature=0.7,  # 調整此值改變創意程度
    max_tokens=150
)

# 內容解密：
# 此程式碼展示瞭如何透過 OpenAI API 設定 temperature 引數。Temperature 控制模型輸出的隨機性，
# 在 0 附近時輸出更確定性和保守；隨著數值升高，回應變得更加多樣化但可能降低準確性。

# 多樣性引數調整範例
response = openai.Completion.create(
    model="gpt-3.5-turbo",
    prompt="分析這個產品的優缺點",
    temperature=0.7,
    top_p=0.9,
    presence_penalty=0.6,
    frequency_penalty=0.5,
    max_tokens=200
)

# 內容解密：
# 這段程式碼示範瞭如何同時調整多個控制引數以獲得更好的文字生成效果。
# 特別注意 presence_penalty 和 frequency_penalty 引數，它們可以有效減少重複內容。

# Logit_bias 精準控制範例
response = openai.Completion.create(
    model="gpt-3.5-turbo",
    prompt="描述雲端運算的優勢",
    logit_bias={
        997: 5,  # 增加"安全"相關詞彙的出現機率
        2231: -2  # 降低"複雜"相關詞彙的出現機率
    },
    max_tokens=150
)

# 內容解密：
# 這段程式碼展示瞭如何使用 logit_bias 引數精確控制模型的詞彙選擇傾向。
# 正值增加特定詞彙出現的可能性，而負值則降低。

# Jinja2 範本範例
from jinja2 import Template

template_string = """
請為一位{{年齡}}歲的{{性別}}推薦三本關於{{主題}}的{{格式}}。
考慮到這位讀者的特點：{{特點}}
"""

template = Template(template_string)
prompt = template.render(
    年齡="25",
    性別="女性",
    主題="人工智慧",
    格式="入門書籍",
    特點="有程式設計基礎但對AI領域陌生"
)

# 內容解密：
# 這段程式碼展示瞭如何使用 Jinja2 範本引擎建立動態提示。
# 範本中的雙大括號是變數佔位符，在渲染時被實際值替換。

# 評分標準定義
rubric = {
    "主題相關性": {
        1: "完全偏離主題",
        2: "勉強相關",
        3: "部分相關",
        4: "大體相關",
        5: "完全符合主題"
    },
    "格式適配性": {
        1: "格式完全不符",
        2: "格式基本不符",
        3: "格式部分符合",
        4: "格式大體符合",
        5: "格式完全符合"
    },
    "推薦品質": {
        1: "推薦品質極差",
        2: "推薦品質較差",
        3: "推薦品質一般",
        4: "推薦品質良好",
        5: "推薦品質卓越"
    }
}

# 使用LLM進行評估的範例
evaluation_prompt = f"""
你是一個專業的內容評估工作者。請根據以下評分標準評估推薦結果：

評分標準：
- 主題相關性 (1-5分)：推薦內容與請求主題的相關程度
- 格式適配性 (1-5分)：推薦內容是否符合請求的格式要求
- 推薦品質 (1-5分)：推薦的整體品質和價值

請求：
{original_request}

推薦結果：
{recommendation_output}

請提供每個標準的分數和簡短說明，然後計算平均分。
"""

evaluation_response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": evaluation_prompt}],
    temperature=0.3,
    max_tokens=300
)

from promptflow import tool

@tool
def parse(input: str) -> list:
    # 按雙換行符分割推薦結果為個別電影區塊
    blocks = input.strip().split("\n\n")

    # 解析單個推薦區塊為字典的函式
    def parse_block(block: str) -> dict:
        lines = block.split('\n')
        result = {}
        for line in lines:
            key_value = line.split(': ')
            if len(key_value) == 2:
                key, value = key_value
                result[key.lower().strip()] = value.strip()
        return result

    # 迴圈處理每個區塊並解析為鍵值字典
    parsed_results = [parse_block(block) for block in blocks]
    return parsed_results

Title: The Butterfly Effect
Subject: 5
Format: 5
Genre: 4

Title: Primer 
Subject: 5 
Format: 5 
Genre: 4

Title: Time Bandits
Subject: 5
Format: 5
Genre: 5

[
  {
    "title": "The Butterfly Effect",
    "subject": "5",
    "format": "5",
    "genre": "4"
  },
  {
    "title": "Primer",
    "subject": "5",
    "format": "5",
    "genre": "4"
  },
  {
    "title": "Time Bandits",
    "subject": "5",
    "format": "5",
    "genre": "5"
  }
]

請生成推薦代理的測試資料，包括以下欄位：
1. subject - 例如：time travel, cooking, vacation
2. format - 例如：books, movies, games
3. genre: documentary, action, romance
4. custom: 其他自 batching JSONL 的其他自定義欄位

請以JSON Lines檔案格式輸出10個專案。

inputs:
  task_description: 需要解決的複雜任務描述

components:
  - name: task_decomposition
    type: llm
    inputs:
      task_description: ${inputs.task_description}
      prompt_template: |
        將以下任務分解為多個子任務：
        任務：${inputs.task_description}
        子任務列表：
    outputs:
      sub_tasks: 分解後的子任務列表

  - name: agent1_process_subtask1
    type: llm
    inputs:
      subtask: ${task_decomposition.sub_tasks[0]}
      prompt_template: |
        處理以下子任務：
        子任務：${task_decomposition.sub_tasks[0]}
        處理結果：
    outputs:
      result1: 第一個子任務的處理結果

  - name: agent2_process_subtask2
    type: llm
    inputs:
      subtask: ${task_decomposition.sub_tasks[1]}
      prompt_template: |
        處理以下子任務：
        子任務：${task_decomposition.sub_tasks[1]}
        處理結果：
    outputs:
      result2: 第二個子任務的處理結果

  - name: integrate_results
    type: llm
    inputs:
      result1: ${agent1_process_subtask1.result1}
      result2: ${agent2_process_subtask2.result2}
      prompt_template: |
        根據以下子任務結果，整合出最終答案：
        結果1：${agent1_process_subtask1.result1}
        結果2：${agent2_process_subtask2.result2}
        最終答案：
    outputs:
      final_answer: 整合後的最終答案

outputs:
  task_description: ${inputs.task_description}
  sub_tasks: ${task_decomposition.sub_tasks}
  final_answer: ${integrate_results.final_answer}

inputs:
  task_description: 創作一個短篇故事
  generated_story: 模型生成的故事

components:
  - name: creativity_evaluation
    type: llm
    inputs:
      story: ${inputs.generated_story}
      prompt_template: |
        評估以下故事的創造力：
        故事：${inputs.generated_story}
        創造力評分（1-5）：
    outputs:
      creativity_score: 創造力評分

  - name: coherence_evaluation
    type: llm
    inputs:
      story: ${inputs.generated_story}
      prompt_template: |
        評估以下故事的敘事連貫性：
        故事：${inputs.generated_story}
        連貫性評分（1-5）：
    outputs:
      coherence_score: 連貫性評分

  - name: emotional_resonance_evaluation
    type: llm
    inputs:
      story: ${inputs.generated_story}
      prompt_template: |
        評估以下故事的情感共鳴度：
        故事：${inputs.generated_story}
        情感共鳴度評分（1-5）：
    outputs:
      emotional_resonance_score: 情感共鳴度評分

outputs:
  task_description: ${inputs.task_description}
  generated_story: ${inputs.generated_story}
  creativity_score: ${creativity_evaluation.creativity_score}
  coherence_score: ${coherence_evaluation.coherence_score}
  emotional_resonance_score: ${emotional_resonance_evaluation.emotional_resonance_score}

system:
根據以下上下文回答使用者的問題。答案需簡短精確。如果不確定，請回應「Unsure about answer」。

上下文：{{context}}

user:
問題：{{question}}

# 定義一個簡單的問答函式
def q_and_a(context, question):
    prompt = f"""
    根據以下上下文回答問題。答案需簡短精確。
    如果不確定，請回應「Unsure about answer」。

    上下文：{context}

    問題：{question}
    """
    return generate_response(prompt)

# 使用範例
context = "這是一個測試上下文。"
question = "什麼是上下文？"
print(q_and_a(context, question))

import random

def self_consistency_prompting(problem, num_chains=5):
    # 初始化答案列表
    answers = []

    # 多次呼叫LLM
    for _ in range(num_chains):
        chain = generate_reasoning_chain(problem)
        answer = extract_answer(chain)
        answers.append(answer)

    # 透過多數投票選出最終答案
    final_answer = majority_vote(answers)
    return final_answer

# 輔助函式：生成推理鏈
def generate_reasoning_chain(problem):
    # 這裡應該呼叫LLM來生成推理鏈
    # 為了簡化，我們使用隨機結果模擬
    return random.choice(["答案A", "答案B", "答案C"])

# 輔助函式：提取答案
def extract_answer(chain):
    # 這裡應該從推理鏈中提取最終答案
    return chain

# 輔助函式：多數投票
def majority_vote(answers):
    # 統計每個答案的出現次數
    counts = {}
    for answer in answers:
        counts[answer] = counts.get(answer, 0) + 1
    
    # 傳回出現次數最多的答案
    return max(counts, key=counts.get)

# 使用範例
problem = "這是一個複雜的問題。"
print(self_consistency_prompting(problem))

class TreeNode:
    def __init__(self, state, parent=None):
        self.state = state
        self.parent = parent
        self.children = []

def tree_of_thought_prompting(problem, max_depth=3):
    # 初始化根節點
    root = TreeNode(problem)

    # 擴充套件思維樹
    expand_tree(root, max_depth)

    # 評估並選擇最佳路徑
    best_path = evaluate_tree(root)

    return best_path

def expand_tree(node, max_depth):
    if node.depth >= max_depth:
        return

    # 生成下一個思考步驟
    next_thoughts = generate_next_thoughts(node.state)

    for thought in next_thoughts:
        child = TreeNode(thought, node)
        node.children.append(child)
        expand_tree(child, max_depth)

# 使用範例
problem = "這是一個需要多步推理的問題。"
print(tree_of_thought_prompting(problem))

import pandas as pd

def evaluate_prompts(test_cases, prompt_variants):
    results = []

    for variant in prompt_variants:
        variant_results = []
        for case in test_cases:
            response = generate_response(variant, case["input"])
            score = evaluate_response(response, case["expected_output"])
            variant_results.append({
                "prompt_variant": variant,
                "input": case["input"],
                "response": response,
                "score": score
            })
        
        results.extend(variant_results)

    return pd.DataFrame(results)

# 使用範例
test_cases = [{"input": "測試輸入", "expected_output": "預期輸出"}]
prompt_variants = ["提示變體1", "提示變體2"]
print(evaluate_prompts(test_cases, prompt_variants))

class Agent:
    def __init__(self, name, expertise):
        self.name = name
        self.expertise = expertise

    def process(self, task):
        # 這裡應該呼叫LLM來處理任務
        return f"{self.name} 處理 {task}"

class MultiAgentSystem:
    def __init__(self):
        self.agents = []

    def add_agent(self, agent):
        self.agents.append(agent)

    def solve_problem(self, problem):
        # 簡單地將問題分配給第一個代理
        return self.agents[0].process(problem)

# 使用範例
system = MultiAgentSystem()
system.add_agent(Agent("代理1", "領域專家"))
print(system.solve_problem("複雜問題"))