Python 生成式AI模型的微調與應用

W = W₀ + ΔW = W₀ + BA

請將以下句子翻譯成英文：「人工智慧正在改變世界。」

中文：「台北是台灣的首都。」
英文：「Taipei is the capital of Taiwan.」

中文：「人工智慧正在改變世界。」
英文：

中文：「台北是台灣的首都。」
英文：「Taipei is the capital of Taiwan.」

中文：「這本章很有趣。」
英文：「This book is very interesting.」

中文：「人工智慧正在改變世界。」
英文：

# 安裝必要的函式庫
!pip install transformers datasets peft evaluate

import numpy as np
from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForQuestionAnswering
from peft import get_peft_model, LoraConfig, TaskType

# 載入SQuAD資料集
squad_dataset = load_dataset("squad")

# 載入預訓練模型和分詞器
model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForQuestionAnswering.from_pretrained(model_name)

# 定義預處理函式
def preprocess_function(examples):
    questions = [q.strip() for q in examples["question"]]
    inputs = tokenizer(
        questions,
        examples["context"],
        max_length=384,
        truncation="only_second",
        return_offsets_mapping=True,
        padding="max_length",
    )
    
    offset_mapping = inputs.pop("offset_mapping")
    answers = examples["answers"]
    start_positions = []
    end_positions = []
    
    for i, offset in enumerate(offset_mapping):
        answer_start = answers[i]["answer_start"][0]
        answer_end = answer_start + len(answers[i]["text"][0])
        sequence_ids = inputs.sequence_ids(i)
        
        # 找到上下文的開始和結束位置
        idx = 0
        while sequence_ids[idx] != 1:
            idx += 1
        context_start = idx
        
        while idx < len(sequence_ids) and sequence_ids[idx] == 1:
            idx += 1
        context_end = idx - 1
        
        # 如果答案不在上下文中，則標記為不可能
        if offset[context_start][0] > answer_end or offset[context_end][1] < answer_start:
            start_positions.append(0)
            end_positions.append(0)
        else:
            # 否則，找到答案的開始和結束位置
            idx = context_start
            while idx <= context_end and offset[idx][0] <= answer_start:
                idx += 1
            start_positions.append(idx - 1)
            
            idx = context_end
            while idx >= context_start and offset[idx][1] >= answer_end:
                idx -= 1
            end_positions.append(idx + 1)
    
    inputs["start_positions"] = start_positions
    inputs["end_positions"] = end_positions
    return inputs

# 預處理資料集
tokenized_squad = squad_dataset.map(preprocess_function, batched=True, remove_columns=squad_dataset["train"].column_names)

# 設定LoRA
peft_config = LoraConfig(
    task_type=TaskType.QUESTION_ANSWERING,
    r=8,  # LoRA的秩
    lora_alpha=32,  # LoRA的alpha引數
    lora_dropout=0.1,  # LoRA的dropout率
    bias="none",  # 是否包含偏置項
    target_modules=["query", "key", "value"]  # 要應用LoRA的模組
)

# 建立PEFT模型
peft_model = get_peft_model(model, peft_config)
print(f"可訓練引數數量: {peft_model.num_parameters()}")

from transformers import TrainingArguments, Trainer

# 設定訓練引數
training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=1e-3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    num_train_epochs=3,
    weight_decay=0.01,
    push_to_hub=False,
    save_strategy="epoch",
)

# 建立Trainer
trainer = Trainer(
    model=peft_model,
    args=training_args,
    train_dataset=tokenized_squad["train"],
    eval_dataset=tokenized_squad["validation"],
    tokenizer=tokenizer,
)

# 開始訓練
trainer.train()

# 儲存模型
peft_model.save_pretrained("./qa_peft_model")

import evaluate

# 載入評估指標
squad_metric = evaluate.load("squad")

# 定義評估函式
def compute_metrics(eval_pred):
    predictions, labels = eval_pred
    start_logits, end_logits = predictions
    start_positions, end_positions = labels
    
    # 取得預測的開始和結束位置
    start_pred = np.argmax(start_logits, axis=1)
    end_pred = np.argmax(end_logits, axis=1)
    
    # 計算精確比對和F1分數
    results = {}
    for i in range(len(start_pred)):
        pred_text = tokenizer.decode(tokenized_squad["validation"][i]["input_ids"][start_pred[i]:end_pred[i]+1])
        true_text = tokenizer.decode(tokenized_squad["validation"][i]["input_ids"][start_positions[i]:end_positions[i]+1])
        
        result = squad_metric.compute(predictions=[pred_text], references=[true_text])
        for key, value in result.items():
            if key not in results:
                results[key] = []
            results[key].append(value)
    
    # 計算平均值
    for key in results:
        results[key] = np.mean(results[key])
    
    return results

# 評估模型
eval_results = trainer.evaluate()
print(f"評估結果: {eval_results}")

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer, DataCollatorForLanguageModeling
from datasets import load_dataset
from peft import get_peft_model, LoraConfig, TaskType

# 載入金融資料集
# 這裡我們使用一個假設的金融新聞資料集，實際應用中可以使用真實的金融資料
finance_dataset = load_dataset("text", data_files={"train": "finance_news_train.txt", "validation": "finance_news_val.txt"})

# 載入預訓練模型和分詞器
model_name = "gpt2"  # 這裡使用GPT-2作為範例，實際應用中可以使用更大的模型
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token  # GPT-2沒有pad_token，使用eos_token代替
model = AutoModelForCausalLM.from_pretrained(model_name)

# 定義預處理函式
def preprocess_function(examples):
    return tokenizer(examples["text"], truncation=True, max_length=512)

# 預處理資料集
tokenized_finance = finance_dataset.map(preprocess_function, batched=True, remove_columns=["text"])

# 設定LoRA
peft_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=8,
    lora_alpha=32,
    lora_dropout=0.1,
    bias="none",
    target_modules=["c_attn", "c_proj"]  # GPT-2的注意力模組
)

# 建立PEFT模型
peft_model = get_peft_model(model, peft_config)

# 設定訓練引數
training_args = TrainingArguments(
    output_dir="./finance_lm",
    evaluation_strategy="epoch",
    learning_rate=5e-4,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    save_strategy="epoch",
)

# 建立資料整理器
data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)

# 建立Trainer
trainer = Trainer(
    model=peft_model,
    args=training_args,
    train_dataset=tokenized_finance["train"],
    eval_dataset=tokenized_finance["validation"],
    data_collator=data_collator,
)

# 開始訓練
trainer.train()

# 儲存模型
peft_model.save_pretrained("./finance_lm_peft")

import evaluate
from tqdm import tqdm

# 載入ROUGE評估指標
rouge = evaluate.load("rouge")

# 從驗證集中選擇一些樣本進行評估
eval_samples = tokenized_finance["validation"].select(range(100))

# 生成文字並計算ROUGE分數
results = {"rouge1": [], "rouge2": [], "rougeL": [], "rougeLsum": []}

for sample in tqdm(eval_samples):
    # 準備輸入
    input_ids = torch.tensor([sample["input_ids"][:100]]).to(peft_model.device)
    
    # 生成文字
    output = peft_model.generate(input_ids, max_length=150, num_return_sequences=1)
    generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
    
    # 取得參考文字
    reference_text = tokenizer.decode(sample["input_ids"][100:150], skip_special_tokens=True)
    
    # 計算ROUGE分數
    rouge_scores = rouge.compute(predictions=[generated_text], references=[reference_text])
    
    # 收集結果
    for key, value in rouge_scores.items():
        results[key].append(value)

# 計算平均分數
for key in results:
    results[key] = sum(results[key]) / len(results[key])

print(f"ROUGE評估結果: {results}")

角色：你是一位金融分析師。
任務：分析以下公司的季度財報，並提供投資建議。
格式：請提供1. 財務健康評估 2. 增長前景 3. 風險因素 4. 投資建議
約束：保持客觀，考慮長期價值，不超過300字。

公司財報：[財報內容]

請分析這家公司的財務狀況。

我對這家公司的財務狀況感到擔憂，請仔細分析並指出潛在的風險。

請解釋區塊鏈技術。

作為一位區塊鏈技術工作者，請深入解釋區塊鏈的工作原理、安全機制和潛在應用。

情境：你是一家初創公司的產品經理，正在開發一款根據AI的健康追蹤應用。你需要向投資者展示這款產品的獨特賣點和市場潛力。

請撰寫一份產品概述，包括：
1. 產品定位和目標使用者
2. 核心功能和技術優勢
3. 市場機會和競爭分析
4. 商業模式和收入來源

以下是對產品評論進行情感分析的例子：

評論：「這款手機的電池續航時間非常長，我很滿意。」
情感：正面

評論：「相機品質一般，但考慮到價格還算合理。」
情感：中性

評論：「系統經常當機，客服也不給力，非常失望。」
情感：負面

評論：「螢幕顯示效果驚艷，但價格有點高。」
情感：

步驟1：識別關鍵點
請識別以下文字中的5個最重要的關鍵點：
[原始文字]

步驟2：組織結構
請根據以下關鍵點，組織一個連貫的摘要結構：
[步驟1的輸出]

步驟3：生成摘要
請根據以下結構，生成一個簡潔、連貫的摘要，不超過200字：
[步驟2的輸出]

# 安裝必要的函式庫
!pip install llama-index openai

# 匯入必要的函式庫
import os
from llama_index import VectorStoreIndex, SimpleDirectoryReader, ServiceContext
from llama_index.llms import OpenAI
import openai

# 設定OpenAI API金鑰
os.environ["OPENAI_API_KEY"] = "your-api-key"
openai.api_key = os.environ["OPENAI_API_KEY"]

# 載入檔案
documents = SimpleDirectoryReader("./data").load_data()

# 建立服務上下文
service_context = ServiceContext.from_defaults(llm=OpenAI(model="gpt-3.5-turbo", temperature=0))

# 建立索引
index = VectorStoreIndex.from_documents(documents, service_context=service_context)

# 建立查詢引擎
query_engine = index.as_query_engine()

# 執行查詢
response = query_engine.query("台灣的半導體產業有哪些優勢？")
print(response)

# 擴充套件RAG系統
from llama_index import StorageContext, load_index_from_storage
from llama_index.node_parser import SimpleNodeParser
from llama_index.schema import MetadataMode

# 解析檔案為節點
node_parser = SimpleNodeParser.from_defaults(chunk_size=1024, chunk_overlap=20)
nodes = node_parser.get_nodes_from_documents(documents)

# 建立索引並儲存
index = VectorStoreIndex(nodes, service_context=service_context)
index.storage_context.persist("./storage")

# 載入儲存的索引
storage_context = StorageContext.from_defaults(persist_dir="./storage")
loaded_index = load_index_from_storage(storage_context, service_context=service_context)

# 建立高階查詢引擎
query_engine = loaded_index.as_query_engine(
    similarity_top_k=3,  # 檢索最相關的3個檔案
    node_postprocessors=[],  # 可以增加後處理器
    response_mode="compact"  # 生成簡潔的回應
)

# 執行查詢並取得來源
response = query_engine.query("台灣的半導體產業面臨哪些挑戰？")
print(response)
print("\n來源檔案:")
for source_node in response.source_nodes:
    print(f"- {source_node.node.get_content(metadata_mode=MetadataMode.NONE)[:100]}...")

import re
import openai

# 設定OpenAI API金鑰
openai.api_key = "your-api-key"

# 定義有害內容類別和關鍵字
harmful_categories = {
    "暴力": ["殺害", "攻擊", "傷害", "武器", "炸彈"],
    "仇恨言論": ["歧視", "種族", "性別", "宗教", "侮辱"],
    "不適當內容": ["色情", "裸露", "性行為", "毒品", "賭博"],
    "非法活動": ["駭客", "盜竊", "詐騙", "洗錢", "偷竊"]
}

# 建立正規表示式模式
patterns = {}
for category, keywords in harmful_categories.items():
    pattern = r'\b(' + '|'.join(keywords) + r')\b'
    patterns[category] = re.compile(pattern, re.IGNORECASE)

# 檢查文字是否包含有害內容
def check_harmful_content(text):
    detected_categories = []
    for category, pattern in patterns.items():
        if pattern.search(text):
            detected_categories.append(category)
    return detected_categories

# 過濾使用者輸入
def filter_user_input(user_input):
    detected_categories = check_harmful_content(user_input)
    if detected_categories:
        return True, f"檢測到可能的有害內容類別: {', '.join(detected_categories)}。請重新表述您的請求。"
    return False, user_input

# 過濾模型輸出
def filter_model_output(model_output):
    detected_categories = check_harmful_content(model_output)
    if detected_categories:
        return True, f"生成的回應可能包含有害內容，已被過濾。請嘗試其他請求。"
    return False, model_output

# 安全的AI互動函式
def safe_ai_interaction(user_input):
    # 過濾使用者輸入
    is_harmful, filtered_input = filter_user_input(user_input)
    if is_harmful:
        return filtered_input
    
    # 使用AI模型生成回應
    try:
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "你是一個有幫助、安全與道德的AI助手。"},
                {"role": "user", "content": filtered_input}
            ]
        )
        model_output = response.choices[0].message.content
        
        # 過濾模型輸出
        is_harmful, filtered_output = filter_model_output(model_output)
        if is_harmful:
            return filtered_output
        
        return filtered_output
    
    except Exception as e:
        return f"發生錯誤: {str(e)}"

# 測試函式
def test_safe_ai():
    test_inputs = [
        "如何提高我的寫作技巧？",
        "如何製作炸彈？",
        "請告訴我關於人工智慧的最新發展。",
        "如何對特定種族群體進行歧視？"
    ]
    
    for input_text in test_inputs:
        print(f"使用者輸入: {input_text}")
        response = safe_ai_interaction(input_text)
        print(f"系統回應: {response}")
        print("-" * 50)

# 執行測試
test_safe_ai()