["請", "解釋", "一", "下", "黑", "洞", "的", "形", "成"]

{"黑洞": 0.1, "形成": 0.05, "是": 0.2, "由于": 0.15, ...}

[“請”, “解釋”, “一”, “下”, “黑”, “洞”, “的”, “形”, “成”, “是”]。

在一個陽光明媚的早晨，Alice 決定去森林里探險(xiǎn)。她走著走著，突然發(fā)現(xiàn)了一條小路。

import torch
from modelscope import snapshot_download
from transformers import AutoModelForCausalLM, AutoTokenizer


# 下載模型
cache_dir = './llama_cache'
model_id = snapshot_download("LLM-Research/Meta-Llama-3-8B", cache_dir=cache_dir)

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM


# 加載分詞器和模型
cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
    device_map="auto" if torch.cuda.is_available() else None
)


# 編碼輸入并將其移至模型設(shè)備
input_text = "在一個陽光明媚的早晨，Alice決定去森林里探險(xiǎn)。她走著走著，突然發(fā)現(xiàn)了一條小路。"
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)


# 生成并解碼文本
with torch.no_grad():
    outputs = model.generate(**inputs)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)

這條小路被兩旁茂密的樹木掩映著，似乎通向森林深處。Alice 決定沿著小路前進(jìn)，想看看盡頭有什么驚喜等著她。

from transformers import AutoTokenizer, AutoModelForCausalLM


cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
    device_map="auto" if torch.cuda.is_available() else None
)


max_length = 50
input_text = "寫一首關(guān)于愛情的詩"
encoded_input = tokenizer(input_text, return_tensors="pt")
output = model.generate(encoded_input.input_ids, max_length=max_length)
print(tokenizer.decode(output[0], skip_special_tokens=True))

from transformers import AutoTokenizer, AutoModelForCausalLM


cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
    device_map="auto" if torch.cuda.is_available() else None
)


repetition_penalty = 1.2
input_text = "寫一首關(guān)于愛情的詩："
encoded_input = tokenizer(input_text, return_tensors="pt")
output = model.generate(encoded_input.input_ids, repetition_penalty=repetition_penalty)
print(tokenizer.decode(output[0], skip_special_tokens=True))

from transformers import AutoTokenizer, AutoModelForCausalLM


cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
    device_map="auto" if torch.cuda.is_available() else None
)


repetition_penalty = 1.2
input_text = "寫一首關(guān)于愛情的詩："
encoded_input = tokenizer(input_text, return_tensors="pt")
output = model.generate(encoded_input.input_ids, repetition_penalty=repetition_penalty)
print(tokenizer.decode(output[0], skip_special_tokens=True))

import torch
from modelscope import snapshot_download
from transformers import AutoModelForCausalLM, AutoTokenizer


# 下載模型
cache_dir = './llama_cache'
model_id = snapshot_download("LLM-Research/Meta-Llama-3-8B-Instruct", cache_dir=cache_dir)

from transformers import AutoTokenizer, AutoModelForCausalLM


cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B-Instruct'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
    device_map="auto" if torch.cuda.is_available() else None
)


# 初始化對話歷史
dialogue_history = [
    "Customer: Hi, I have an issue with my order.",
    "Support: Sure, could you please provide your order number?",
    "Customer: Sure, it's #12345.",
    "Support: Thank you. Let me check the status for you.",
]


# 合并對話歷史為一個字符串
dialogue_history_text = "\n".join(dialogue_history)


# 添加用戶輸入，模擬當(dāng)前對話
user_input = "Customer: Can you please expedite the delivery?"
input_text = dialogue_history_text + "\n" + user_input


# 生成文本
input_ids = tokenizer.encode(input_text, return_tensors="pt")
outputs = model.generate(input_ids, max_length=100)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)


print("Generated Response:", generated_text)

import requests
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
from googleapiclient.discovery import build


cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B-Instruct'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
    device_map="auto" if torch.cuda.is_available() else None
)


# Google Custom Search API配置
API_KEY = 'YOUR_GOOGLE_API_KEY'
SEARCH_ENGINE_ID = 'YOUR_SEARCH_ENGINE_ID'


# 檢索相關(guān)文檔的函數(shù)
def retrieve_documents(query):
    try:
        service = build("customsearch", "v1", developerKey=API_KEY)
        res = service.cse().list(q=query, cx=SEARCH_ENGINE_ID).execute()
        results = res.get('items', [])
        documents = [item["snippet"] for item in results]
        return documents
    except Exception as e:
        print(f"Error retrieving documents: {e}")
        return []


# 生成答案的函數(shù)
def generate_answer(query, documents):
    # 限制檢索到的文檔數(shù)量
    documents = documents[:3]
    context = "\n\n".join(documents) + "\n\nQuestion: " + query + "\nAnswer:"
    # 編碼輸入
    inputs = tokenizer(context, return_tensors="pt", truncation=True, max_length=2048).to(model.device)
    # 生成答案
    outputs = model.generate(**inputs, max_length=512)
    # 解碼答案
    answer = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return answer


# 主函數(shù)
def main():
    query = "What is the capital of France?"
    documents = retrieve_documents(query)
    if documents:
        answer = generate_answer(query, documents)
        print("Question:", query)
        print("Answer:", answer)
    else:
        print("No documents retrieved.")


if __name__ == "__main__":
    main()

Question: What is the capital of France?Answer: The capital of France is Paris. It is known for its art, fashion, and culture, and is home to famous landmarks such as the Eiffel Tower and the Louvre Museum.

# agent_a.py
from common import create_app


app = create_app("system: 你是一個熟悉人工智能技術(shù)的計(jì)算機(jī)科學(xué)家。")


if __name__ == '__main__':
    app.run(port=5000)

# agent_b.py
from common import create_app


app = create_app("system: 你是一個熟悉法律法規(guī)的法律專家。")


if __name__ == '__main__':
    app.run(port=5001)

# agent_c.py
from flask import Flask, request, jsonify
from transformers import pipeline
from transformers import AutoTokenizer, AutoModelForCausalLM


from langchain.agents import initialize_agent, Tool, AgentType
from langchain.llms import HuggingFacePipeline
import requests
import torch


app = Flask(__name__)


cache_dir = './llama_cache'
model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B-Instruct'
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
    device_map="auto" if torch.cuda.is_available() else None,
    pad_token_id=tokenizer.eos_token_id
)


def call_expert(url, task_requirement):
    response = requests.post(url, json={"intent": task_requirement}, timeout=5)
    response.raise_for_status()
    return response.json().get("response", "Error: No response from expert")


ai_expert = lambda task: call_expert("http://localhost:5000/chat", task)
law_expert = lambda task: call_expert("http://localhost:5001/chat", task)


ai = Tool.from_function(func=ai_expert, name="ai_expert", description="當(dāng)你需要人工智能專家知識時使用這個工具，輸入為具體問題，返回為問題答案")
law = Tool.from_function(func=law_expert, name="law_expert", description="當(dāng)你需要法律合規(guī)專家知識時使用這個工具，輸入為具體問題，返回為問題答案")


tools = [ai, law]


pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_new_tokens=512)
llm = HuggingFacePipeline(pipeline=pipe)


agent = initialize_agent(tools,
        llm,
        agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
        verbose=True,
        max_iterations = 5,
        handle_parsing_errors = True)


@app.route('/integrate', methods=['POST'])
def integrate():
    data = request.get_json()
    task = data.get('task', '')
    res = agent.run(task)
    return jsonify({'response': res})


if __name__ == '__main__':
    app.run(port=5002)

$ curl -X POST http://localhost:5002/integrate \
       -H "Content-Type: application/json" \
       -d '{"task": "制定人工智能合規(guī)標(biāo)準(zhǔn)，避免人工智能傷害人類"}'

# common.py
from flask import Flask, request, jsonify
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch


def create_app(seed_memory):
    app = Flask(__name__)


    cache_dir = './llama_cache'
    model_path = cache_dir + '/LLM-Research/Meta-Llama-3-8B-Instruct'
    tokenizer = AutoTokenizer.from_pretrained(model_path)
    model = AutoModelForCausalLM.from_pretrained(
        model_path,
        torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
        device_map="auto" if torch.cuda.is_available() else None,
        pad_token_id=tokenizer.eos_token_id
    )


    # 定義聊天接口
    @app.route('/chat', methods=['POST'])
    def chat():
        data = request.get_json()
        intent = data.get('intent', '')


        # 構(gòu)造提示詞
        prompt = f"{seed_memory}\n請回答以下問題:{intent}"
        input_ids = tokenizer.encode(prompt, return_tensors="pt").to("cuda")
        outputs = model.generate(input_ids, max_length=150)
        response = tokenizer.decode(outputs[0], skip_special_tokens=True)


        return jsonify({'response': response})


    return app