使用 Python 和 OpenAI，透過大型語言模型 (LLM) 對多智能體餐廳進行實際模擬。

上週，OpenAI 發布了一份文件 PDF大家都在談論它。這份34頁的文檔是一份指南，解釋了什麼是大型語言模型代理（LLM代理）以及如何使用它們。

這份PDF文件篇幅較短，也容易閱讀（無需成為軟體工程師/程式設計師即可理解），但它用寥寥數語解釋了三件事：

1. 大型語言模型代理（LLM代理） “它們是能夠代表你獨立完成任務的系統。”

所以，這些不就是透過 API 呼叫簡單的大型語言模型 (LLM) 宣告嗎？嗯，可以說是，也可以說不是。你使用的是相同的對話補全模型，所以從某種意義上說，它們確實是。 但 這指的是創建特定的流程。我的意思是，你的代理的輸出。 必須將其轉化為可執行的成果。 在你的系統中。例如，如果大型語言模型（LLM）的輸出是“spaghetti”，那麼“spaghetti”就會被添加到你的數據路徑中，最終會有人看到它並烹飪意大利麵（發出警報）。

2. 大型語言建模代理（LLM代理）尤其與…集成 功能（工具）

我指的是你向 ChatGPT 提問，它會呼叫其圖像生成器/網頁查找器/程式碼片段的場景。在內部，它使用一個名為「工具」的函數，該函數由你的提示觸發。圖像生成器是一個內建函數，但它也可以呼叫[命令/程式碼片段]。 你的工作（你的工具）您可以根據具體任務進行客製化。這種整合外部工具和功能的能力賦予了大型語言模型代理（LLM代理）強大的靈活性和執行各種任務的能力。

 

3. 可整合多個大型語言模型（LLM）代理程式。 陸續。

你可以將單一代理與多個工具組合在一起。 أو 我們將把工具劃分成專門的代理，這也是我們將在本文中所做的（另一個提示！）。

技術細節可能對軟體工程師來說很有趣，但為什麼代理這個主題對其他人來說如此重要呢？
因為這代表著重大飛躍，有助於為 OpenAI 模型帶來許多好處。想想看：現在大型語言模型 (LLM) 能夠提供… 可執行的成果。 因此，關鍵不在於在工作流程的最後一步使用大型語言模型（LLM）聲明來改善最終輸出；而在於… 透過將整個工作流程與大型語言模型代理（LLM代理）集成 為了提高整個工作流程的品質。

雖然我試著用語言解釋，但我認為用實際演示更容易理解。假設我們正在討論… 餐廳， 例如。

典型的餐廳流程非常簡單：排隊、點餐、等餐、用餐、離開。如果我們用「代理」的觀點來描述這個過程，至少可以辨識出三個代理：

• 代理人 客戶 他是一個大型語言模型（LLM）代理，可以點餐或向服務員尋求建議。
• 代理人 服務生 它是一種大型語言模型（LLM），可以收集請求並在必要時提供建議。
• 代理人 娛樂 這是一個大型語言模型（LLM），旨在處理客戶投訴。

現在，OpenAI 會具體告訴你如何建立這些實體，但這只是相對容易的部分；還有很多其他方面需要考慮，不是嗎？

我們需要實施 真主我們需要創造 排隊方法我們需要依照餐廳的繁忙程度來安排顧客的座位。 穆斯林日報模擬 等待時間並確保一切運作正常。 然後 只有那時 我們可以聯繫代理商。一如既往：

 

生成式人工智慧功能強大，前提是使用得當。

所以，在深入探討經紀人這個令人興奮的部分之前，您將在本文中看到以下內容：

1. 系統設計 為LLM代理餐廳構思。沒有程式碼說明，只有紙筆（或更確切地說是滑鼠和PowerPoint）繪製的項目草圖。
2. 無代理餐廳部署。 簡單直接，只是為了創建程式碼的基本結構。
3. 代理餐廳實現。 除了簡潔的圖形使用者介面，以實現良好的顯示效果。
4. 最後的一些考慮和意見。

看來我們有很多東西要學。去實驗室吧！ 🧪

1. 餐廳系統設計：專家指南

注意：如果您做過一些技術工作，您會發現這個系統設計相當簡單明了。我們的目標並非全面概述機器學習系統的各個方面（就像15分鐘面試中他們會問的那樣🙃），而是僅僅為您提供一些下一步工作的指導。

我們可以將餐廳流程視覺化，並將其與大型語言模型（LLM）結合，如下圖所示：

讓我解釋一下：

• 餐廳（） 和 菜單（） 這裡有兩個類別。我們定義它們，類別中的所有表、請求和系統資訊都將在類別中定義並動態更新。
• 他們必須 新客戶 進入座位安排流程。如果有足夠的空桌，那就太好了，我們可以讓他們入座；否則，顧客就得排隊等候。
• 對於客戶而言 坐著會有服務生幫他們點餐。他們可以“抱怨”，詢問點餐後食物需要多久才能上菜。
• 人們無法 排隊的人 他們做了很多事，但他們也會“抱怨”，會問他們要排隊等多久才能坐下。

現在，仔細想想，你並不是 需要 為此，我們可以採用大型語言模型（LLM）。例如，我們可以預先計算等待時間，然後將其與預先定義的結構化字串關聯起來。我們也可以使用簡單的清單來收集訂單（就像麥當勞的自助點餐機那樣），然後就大功告成了。當然，我們可以這樣做，但請仔細想想。

如果顧客想了解選單資訊怎麼辦？ 等待中如果他們真是那樣呢？ 猶豫不決 關於食物方面呢？如果他們想知道呢？ 最美味的素食選擇 菜單上有嗎？如果他們想要呢？ 價格合理的優質葡萄酒我們可以選擇為每個場景定義基於規則的方法，但這會浪費時間和金錢；或者，我們可以開始使用人工智慧。本文將探討的就是人工智慧。如果我們使用大型語言模型代理（LLM代理），就能一次處理所有這些場景。

現在，如果說我學到了什麼，那就是軟體工程必須有人去做。 一步步最好你擁有 骨骼 接下來，為您的模型添加裝飾和附加功能。為此，我們將建立上述產品的無代理版本。這個簡化版本將配備一個隊列系統，用於計算等待時間並執行選單，因此無需任何人工智慧即可流暢運行。完成此步驟後，我們可以將代理商放置在我們之前討論和演示過的位置（顧客、接待員和侍者）。

2. 無代理實現

主腳本最好始終保持盡可能簡潔，將複雜的操作放在背景執行。我們的無代理實作可以在這段程式碼中運行。

import random import time import math import sys from utils import * from constants import * from naive_models import * if __name__ == "__main__": random.seed(42) menu = preprocess_menu(MENU_FILE, eat_seed(42) menu = preprocess_menu(MENU_FILE, eat_5"""",li_r(MENUs_menu(MENU_FILE, eat_5))d arrival_prob=0.7, tick_length=1, real_pause=5.0, query_prob=0.4, menu=menu ) R.run(total_time=60)

正如我們所見，我們可以改變：

• 表格數量我們餐廳的桌子數量。
• 到達機率它是顧客在每個時間點到達的機率。
• 蜱這是我們模擬的時間步長。
• 暫停它組織了 time.sleep() 函數，並用於模擬真實餐廳的工作流程。

現在，所有這些操作都在一個文件中完成。 naive_models.py現有的 這裡.

import random
import time
import math
import sys
from utils import *
from constants import *

class Table:
def __init__(self, id, capacity=1):
self.id = id
self.capacity = capacity
self.is_free = True
self.cust_id = None
self.plate = None
self.cooking_complete_at = None
self.leave_at = None

def seat(self, cust_id, clock, plate, cook_time, eat_time):
self.is_free = False
self.cust_id = cust_id
self.plate = plate
self.cooking_complete_at = clock + cook_time
self._scheduled_eat_time = eat_time
msg = (
f"[{clock:04}m] 🪑 Seated customer {cust_id} at T{self.id} "
f"ordering {plate!r} (cook {cook_time}m, eat {eat_time}m)"
)
print(msg); sys.stdout.flush()

def start_eating(self, clock):
self.leave_at = clock + self._scheduled_eat_time
msg = (
f"[{clock:04}m] 🍽️ Customer {self.cust_id} at T{self.id} "
f"starts eating their {self.plate!r} (leaves at {self.leave_at}m)"
)
print(msg); sys.stdout.flush()

def depart(self, clock):
msg = (
f"[{clock:04}m] 💸 Customer {self.cust_id} finished their "
f"{self.plate!r} and left T{self.id}"
)
print(msg); sys.stdout.flush()
self.is_free = True
self.cust_id = None
self.plate = None
self.cooking_complete_at = None
self.leave_at = None

class Restaurant:
def __init__(self, num_tables, arrival_prob=0.33,
tick_length=1, real_pause=0.5, menu=None,
query_prob=0.0):
self.tables = [Table(i) for i in range(num_tables)]
# queue holds only customer IDs
self.queue = []
self.clock = 0
self.next_cust_id = 1
self.arrival_prob = arrival_prob
self.tick = tick_length
self.pause = real_pause
self.menu = menu or [
("Burger", 2, 4),
("Pasta", 3, 5),
("Salad", 1, 2),
("Steak", 4, 6),
("Soup", 1, 3),
]
self.query_prob = query_prob

total = sum(c + e for _, c, e in self.menu)
self.avg_service_time = total / len(self.menu)

def open_tables(self):
return [t for t in self.tables if t.is_free]

def _pick_dish(self):
return random.choice(self.menu)

def arrive(self):
if random.random() < self.arrival_prob:
cid = self.next_cust_id
self.next_cust_id += 1
free = self.open_tables()
if free:
# pick dish only when seating immediately
plate, cook_time, eat_time = self._pick_dish()
table = min(free, key=lambda t: t.capacity)
table.seat(cid, self.clock, plate, cook_time, eat_time)
else:
self.queue.append(cid)
print(f"[{self.clock:04}m] ⏳ Queued customer {cid} (waiting)")

def process_cooking(self):
for t in self.tables:
if (not t.is_free
and t.cooking_complete_at is not None
and t.cooking_complete_at <= self.clock
and t.leave_at is None):
t.start_eating(self.clock)

def process_departures(self):
for t in self.tables:
if (not t.is_free
and t.leave_at is not None
and t.leave_at <= self.clock):
t.depart(self.clock)

def seat_from_queue(self):
while self.queue and self.open_tables():
cid = self.queue.pop(0)
# pick dish at seating time
plate, cook_time, eat_time = self._pick_dish()
table = min(self.open_tables(), key=lambda t: t.capacity)
table.seat(cid, self.clock, plate, cook_time, eat_time)

def estimate_queue_time(self, cid):
positions = list(self.queue)
idx = positions.index(cid)
raw_wait = (idx + 1) * self.avg_service_time / len(self.tables)
return math.ceil(raw_wait)

def estimate_food_time(self, cid):
for t in self.tables:
if t.cust_id == cid:
if t.cooking_complete_at > self.clock:
return t.cooking_complete_at - self.clock
return max(0, t.leave_at - self.clock)
return None

def handle_random_query(self):
queue_ids = list(self.queue)
seated_ids = [t.cust_id for t in self.tables if not t.is_free]
if queue_ids and (not seated_ids or random.random() < 0.7):
cid = random.choice(queue_ids)
wait = self.estimate_queue_time(cid)
print(f"[{self.clock:04}m] ❓ Customer {cid}: How long will I be in line?")
print(f"[{self.clock:04}m] ➡️ Estimated wait for customer {cid}: {wait}m")

elif seated_ids:
cid = random.choice(seated_ids)
wait = self.estimate_food_time(cid)
table = next(t for t in self.tables if t.cust_id == cid)
food = table.plate
print(f"[{self.clock:04}m] ❓ Customer {cid}: How long will the {food} take me?")
if wait is None:
print(f"[{self.clock:04}m] ➡️ Ready now!")
else:
print(f"[{self.clock:04}m] ➡️ Estimated food wait for customer {cid}: {wait}m")

def tick_once(self):
self.arrive()
self.process_cooking()
self.process_departures()
self.seat_from_queue()
if self.query_prob and random.random() < self.query_prob:
self.handle_random_query()
self.clock += self.tick
time.sleep(self.pause)

def run(self, total_time):
while self.clock < total_time:
self.tick_once()
print("n--- END OF SHIFT ---")
free = sum(t.is_free for t in self.tables)
print(f"{free}/{len(self.tables)} tables free at {self.clock}m.")

if __name__ == "__main__":
random.seed(42)
menu = preprocess_menu(MENU_FILE, eat_time_factor=0.5)
R = Restaurant(
num_tables=2,
arrival_prob=0.7,
tick_length=1,
real_pause=5.0,
query_prob=0.4,
menu=menu
)
R.run(total_time=60)

這是一個很長的過程，讓我一步一步來講解一下。

整個腳本使用以下命令在 naive_sim 上執行。 。跑步（） 具備以下功能：

• 到達這代表顧客的到來及其請求，或顧客的到來及其在隊列中的位置。
• 烹飪過程它模擬了每張餐桌的烹飪過程。
• 處理出發模擬顧客離開的情況。
• 從隊列中選座模擬顧客從等候名單入座的情況。
• 處理隨機查詢通話是隨機的，排隊等候或等待食物的顧客可以詢問等待時間。

如果我們運行 naive_sim.py，我們將從設備中獲取此資訊。

這本身就是一個數據科學產品。你可以用它來運行蒙特卡洛鍊式反應；你可以預測排長隊的可能性。餐廳可以使用這個「數位孿生」來模擬他們的餐廳，並預測何時可能出現關鍵問題。既然我們已經有了一個可用的產品，讓我們利用人工智慧（AI）讓它變得更好、更強大吧。

3. 啟動代理餐廳實施系統

如上所示，顧客已經可以提問，我們會以數字形式提供答案。顧客也可以隨機選擇我們系統中的菜色。現在，我們嘗試在這個系統中加入客服人員。啟用餐廳客服系統是實現客戶服務自動化和提升用戶體驗的重要一步，因為經過培訓的客服人員可以有效率地解答顧客的諮詢並提供個人化的推薦。

3.1 實施專用代理

您需要安裝“代理”模組：

以下是客服專員、娛樂專員和投訴處理專員的實現方式。

# custom_agents.py import os, json from openai import OpenAI from agents import Agent from newtools import * client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"), default_headers={"OpenAI-Beta":"assistants=v2"}) menu_agent = Agent(name = "Chef_suggester", instructions = "您是一位了解我們餐廳一切的貼心服務員，正在幫助顧客選擇菜餚。您將首先禮貌地" "介紹自己是美食虛擬助手，並禮貌地向顧客問好。顧客的姓名可以在 msg json 文件中找到" "您將閱讀菜單，並根據顧客在 json 文件鍵中提出的問題，格式 '{food:地位： }'", tools = [get_menu]) enterer_agent = Agent(name = "娛樂者", instructions = ("您是樂於助人的服務員，負責在顧客等待時讓他們_可做。" 您不能提供任何折扣或優惠，但他們可以詢問菜單相關問題，您可以從「get_menu」中獲取他們的時間包含時間。 user_status 為 'queue'，請根據等待時間友好地告知他們等待時間。 = ("您是一位顧客，正在義大利餐廳用餐。查看使用 `get_menu` 函數獲取菜單。如果您已經知道自己想要什麼，只需告訴服務員即可。「否則，請大致說明，或根據您的喜好尋求建議，他們會為您挑選最好的菜品。」），`tools = [get_menu]``defbgenta)。 "entertainer": return runner.run_sync(entertainer_agent, msg) elif class_agent == "waiter": return runner.run_sync(menu_agent, msg) elif class_agent == "customer": return runner.omer_sygent())

我們有一個定義 客戶這是對 OpenAI 客戶端的調用， newtools.py負責抽取名單的人 呼叫代理 它透過召喚和佔據個體代理人來做到這一點。 亞軍這些組件對於創建有效的代理系統至關重要。

這正是我們在引言中討論的內容。我們正在概述幾個方面。 代理人 它們將連接在一起，並且它們正在使用 工具 這些工具和代理程式由我的程式碼專門定義，可實現客戶服務任務的自動化，並改善使用者體驗。

from agents import function_tool from constants import * import pandas as pd @function_tool def get_menu(): df = pd.read_csv(MENU_FILE) # 轉換為字典列表（或可序列化為 JSON 的結構） return df.to_dics"

3.2 實施專用代理

實施已合併 枱燈 和 餐廳 使用以下程式碼中的代理程式：

 

import random import time import math import sys from utils import * from constants import * import time, random, json from custom_agents import * from utils import * from constants import * from agents 列表 import * from utils import * from constants import * from agents import Runner 列表常數 ] is defined in constants.py
import logging

# Set up logging

def log(msg):
logging.info(msg)

class Table:
def __init__(self, id, capacity=1):
self.id = id
self.capacity = capacity
self.is_free = True
self.cust_id = None
self.orders = [] # list of (plate, cook_time, eat_time)
self.current_phase = None # "cooking" or "eating"
self.cooking_complete_at = None
self.leave_at = None

def seat(self, cust_id, cust_name, clock, orders):
self.is_free = False
self.cust_id = cust_id
self.orders = list(orders) # copy the list of tuples
# start first dish cooking immediately
plate, cook_time, eat_time = self.orders.pop(0)
self.current_phase = "cooking"
self._scheduled_eat_time = eat_time
self._remaining_orders = self.orders # save the tail
self.cooking_complete_at = clock + cook_time
self.leave_at = None
msg = (f"[{clock:04}m] 🪑 Seated {cust_name} (#{cust_id}) at T{self.id} "
f"ordering {len(orders)} dishes; first: {plate!r} "
f"(cook {cook_time}m, eat {eat_time}m)")
print(msg); sys.stdout.flush()

def start_eating(self, clock):
self.current_phase = "eating"
self.leave_at = clock + self._scheduled_eat_time
plate = self.plate if hasattr(self, 'plate') else "dish"
msg = (f"[{clock:04}m] 🍽️ {plate!r} ready for {self.cust_name} "
f"(#{self.cust_id}) at T{self.id}, eating until {self.leave_at}m")
print(msg); sys.stdout.flush()

def finish_phase(self, clock):
"""Called when eating of current dish finishes."""
if self._remaining_orders:
# move to next dish
plate, cook_time, eat_time = self._remaining_orders.pop(0)
self.current_phase = "cooking"
self._scheduled_eat_time = eat_time
self.cooking_complete_at = clock + cook_time
self.leave_at = None
self.plate = plate
msg = (f"[{clock:04}m] 🔄 Next dish for {self.cust_name} (#{self.cust_id}) "
f"at T{self.id}: {plate!r} (cook {cook_time}m, eat {eat_time}m)")
print(msg); sys.stdout.flush()
else:
# no more dishes: depart
msg = (f"[{clock:04}m] 💸 {self.cust_name} (#{self.cust_id}) "
f"finished all dishes and left T{self.id}")
print(msg); sys.stdout.flush()
self.is_free = True
self.cust_id = None
self.orders = []
self.current_phase = None
self.cooking_complete_at = None
self.leave_at = None

class Restaurant:
def __init__(self, num_tables, arrival_prob=0.33,
tick_length=1, real_pause=0.5, menu=None,
query_prob=0.0):
self.tables = [Table(i) for i in range(num_tables)]
self.queue = [] # just customer IDs
self.clock = 0
self.next_cust_id = 1
self.arrival_prob = arrival_prob
self.tick = tick_length
self.pause = real_pause
self.menu = menu or [
("Burger", 2, 4),
("Pasta", 3, 5),
("Salad", 1, 2),
("Steak", 4, 6),
("Soup", 1, 3),
]
self.runner = Runner()
self.query_prob = query_prob
self.names = {}
self.load_logging()

def load_logging(self):
logging.getLogger("httpx").setLevel(logging.WARNING)
logging.getLogger("openai").setLevel(logging.WARNING)
logging.getLogger("urllib3").setLevel(logging.WARNING)
logging.basicConfig(level=logging.INFO, format='[%(asctime)s] %(message)s',
datefmt='%H:%M:%S', handlers=[
logging.FileHandler("restaurant_log.txt", mode='w'),
logging.StreamHandler(sys.stdout)])

def log_to_msg(self,msg):
logging.info(msg)

def open_tables(self):
return [t for t in self.tables if t.is_free]

def _pick_orders(self, cname):
"""Choose between 1–3 random menu items as a list."""
#n = random.randint(1, 3)
#return random.sample(self.menu, n)
customer_text = call_agent(runner = self.runner, msg= '', class_agent="customer").final_output
msg = f'The customer {cname} is talking to the waiter, saying this {customer_text}'
print(msg)
self.log_to_msg(msg)
menu_asker_output = call_agent(runner = self.runner, msg = json.dumps(customer_text), class_agent="waiter").final_output
output = extract_json_dict(menu_asker_output)
msg = f'The processed response from our LLM is {output}'
print(msg)
self.log_to_msg(msg)
if output['status'] == 'successfull':
return filter_menu_items(output['food'])
else:
n = random.randint(1, 3)
return random.sample(self.menu, n)

def _assign_name(self, cid):
name = random.choice(NAMES)
self.names[cid] = name
return name

def arrive(self):
if random.random() < self.arrival_prob:
cid = self.next_cust_id
self.next_cust_id += 1
cname = self._assign_name(cid)
free = self.open_tables()
if free:
orders = self._pick_orders(cname)
table = min(free, key=lambda t: t.capacity)
table.cust_name = cname
plate, cook_time, eat_time = orders[0]
table.plate = plate
table.seat(cid, cname, self.clock, orders)
else:
self.queue.append(cid)
msg = f"[{self.clock:04}m] ⏳ Queued {cname} (#{cid}) – waiting"
print(msg)
self.log_to_msg(msg)

def process_cooking(self):
for t in self.tables:
if (not t.is_free and
t.current_phase=="cooking" and
t.cooking_complete_at <= self.clock):
# cooking done → start eating
t.cust_name = self.names[t.cust_id]
t.start_eating(self.clock)

def process_departures(self):
for t in self.tables:
if (not t.is_free and
t.current_phase=="eating" and
t.leave_at <= self.clock):
t.cust_name = self.names[t.cust_id]
t.finish_phase(self.clock)

def seat_from_queue(self):
while self.queue and self.open_tables():
cid = self.queue.pop(0)
cname = self.names[cid]
orders = self._pick_orders(cname=cname)
table = min(self.open_tables(), key=lambda t: t.capacity)
table.cust_name = cname
plate, cook_time, eat_time = orders[0]
table.plate = plate
table.seat(cid, cname, self.clock, orders)

def estimate_queue_time(self, cid):
# same logic as before: position in queue × avg service
avg = sum(c+e for _,c,e in self.menu) / len(self.menu)
idx = self.queue.index(cid)
return math.ceil((idx+1)*avg/len(self.tables))

def estimate_food_time(self, cid):
for t in self.tables:
if t.cust_id == cid:
# if they’re still cooking, time until cook‐done
if t.current_phase == "cooking":
return max(0, t.cooking_complete_at - self.clock)
# if they’re eating, time until they finish eating
if t.current_phase == "eating":
return max(0, t.leave_at - self.clock)
return None

def handle_random_query(self):
queue_ids = list(self.queue)
seated_ids = [t.cust_id for t in self.tables if not t.is_free]
if queue_ids and (not seated_ids or random.random() < 0.7):
cid = random.choice(queue_ids)
wait = self.estimate_queue_time(cid)
cname = self.names[cid]
msg = f"[{self.clock:04}m] ❓ Customer {cid}: How long will I be in line?"
print(msg) self.log_to_msg(msg) msg​​ = f"[{self.clock:04}m] ➡️ 顧客 {cid} 的預計等待時間：{wait}m" print(msg) self.log_to_msg(msgomer) wait}m" print(msg) self.log_to_msg(msgomer) waging_ cname, "type": "line", "wait_min": wait, "next_food": None } output_llm = call_agent(class_agent="entertainer", runner = self.runner, msg = json.dumps(waiting_message)) msg​​ f 的 LLM LLM 為我們的 LLM 為提供了以下服務：{output_llm}" print(msg) self.log_to_msg(msg) elif seated_ids: cid = random.choice(seated_ids) wait = self.estimate_food_time(cid) table = next(t for in self. cname = self.names[cid] msg = f"[{self.clock:04}m] ❓ 顧客 {cid}：請問食物要多久？"
print(msg) self.log_to_msg(msg) if wait is None: msg = f"[{self.clock:04}m] ➡️ Ready now!"
print(msg) self.log_to_msg(msg) else: msg = f"[{self.clock:04}m] ➡️ 顧客 {cid} 的預期食物等待時間：{wait}m" print(msg) self.log_to_msg(msgomer) wait}m" print(msg) self.log_to_msg(msgomer) wait; cname, "type": "line", "wait_min": wait, "next_food": food } output_llm = call_agent(class_agent="entertainer", runner = self.runner, msg = json.dumps(waiting_message)) msg​​ f 的 LLM LLMc.的訂單：{output_llm}" print(msg) self.log_to_msg(msg) def tick_once(self): self.arrive() self.process_cooking() self.process_departures()如果 f.query_proom 且 self. self.handle_random_query() self.clock += self.tick time.sleep(self.pause) def run(self, total_time): while self.clock < total_time: self.tick_once() free = sum(t.is_ fortal_time： ---n{free}/{len(self.tables)} 張表在 {self.clock} 分鐘時空閒。
print(msg) self.log_to_msg(msg) if __name__ == "__main__": random.seed(42) menu = preprocess_menu(MENU_FILE, eat_time_factor=0.5) R = Restaurant( num_tables=5.0, 000by> query_prob=0.8, menu=menu ) R.run(total_time=60)

3.3 使用大型語言模型 (LLM) 為餐廳實現圖形使用者介面 (GUI)

為了展示餐廳在使用大型語言模型 (LLM) 應用程式時的效能，我們將使用簡單的圖形使用者介面 (GUI)。

from llm_models_gui import RestaurantGUI from utils import * import random from llm_models import Restaurant if __name__ == "__main__": random.seed(42) menu = preprocess_menu(MENU_FILE, eat_table_fa.0. tick_length=1, real_pause=1.0, # smoother for GUI query_prob=0.8, menu=menu ) app = RestaurantGUI(R)

圖形使用者介面 (GUI) 提供有關人員（Emma）、表格、時間和大型語言模型 (LLM) 輸出的資訊。系統也會自動產生一個 .txt 記錄。

讓我給你展示一下輸出結果的例子：

[12:31:23] 顧客艾瑪對服務員說：“我想先點一份意式烤麵包作為開胃菜。然後我想點一份意大利麵配培根蛋麵作為主菜。甜點我想吃提拉米蘇。您能推荐一款適合搭配這頓飯的葡萄酒嗎？” [12:31:25] 我們碩士生處理的答案是：{'food': ['Bruschetta', 'Spaghetti Carbonara', 'Tiramisu', 'Chianti Classico'], 'status': 'successful'} [12:31:25] [0000m] ❓ 顧客需要好多久才能準備好？ [12:31:25] [0000m] ➡️ 顧客預計等待時間：1:15 分鐘 [12:31:26] 法學碩士生接手 Emma 的事務，內容如下：最後一位顧客：Agent(name=”Entertainer”, …) 最終結果（系列）：你好 Emma！ 感謝您的耐心等待。 等候入場時間約15分鐘。 我們快到了－有足夠的時間開始憧憬那美味的義式烤麵包了！ 🍽️

我們可以展示：

1. 顧客透過代理商創建自己的菜單。他請求服務員的經紀人提供推薦信。
2. 服務員推薦了基安蒂葡萄酒，並將其添加到菜單中。
3. 投訴處理人員會告知客戶等待時間。

現在，我們不僅可以像以前一樣模擬工作流程，而且我們實際上擁有了工作流程。 聰明的它採用了相同的 ChatGPT 技術，是不是很棒呢？

 

4.結論

非常感謝你的到來，這對我來說意義重大❤️。
讓我們回顧一下這篇文章的內容。

1. 餐廳系統設計:
   我們使用 PowerPoint 快速設計了餐廳系統，並添加了人工智慧代理。
2. 無代理基金會：
   我們首先建立了一個確定性模擬系統，以便編寫排隊、烹飪時間和餐桌輪換的邏輯。這是我們在實現任何人工智慧之前的框架。
3. 一家依賴代理商的餐廳：
   在這個階段，我們使用人工智慧代理來填充投訴狀態並分配處理方案。我們還創建了一個圖形使用者介面，以便清晰地展示結果。

現在，我想在此先說明一點。我知道這聽起來有點像《黑鏡》裡的劇情。顧客模擬？餐廳和侍者模擬？沒錯，這聽起來很奇怪。 但 問題從來不在於人工智慧工具本身，而是如何使用它。我認為用人工智慧取代人類服務生是一個得不償失的方案。

當服務生不只是接受點單，然後根據客人之前點的酒款推薦第N款。它需要你既熱情友好，讓客人感到賓至如歸，又保持適當的距離，不打擾他們的談話；既親切和藹，讓他們感到自在，又堅定地維護他們的界限。我認為，這需要人情味、耐心和同理心。

然而，我認為這項技術的正確使用可以體現在兩個方面：

1. 幫助那些被列入等候名單的真實病患。 餐廳裡的服務生非常忙碌，餐廳通常會提供菜單供顧客等位時瀏覽；指望服務生專門去招待沒有座位的顧客是不切實際的。在這種情況下，一個可以聊天的AI助理或許會有幫助。
2. 餐廳模擬我寫的這個場景模擬了… 行為 顧客 此外，這意味著您可以利用模擬來測試不同的場景，觀察何時會形成排隊，並預測顧客的不同反應、服務員的不同應對方式等等。換句話說，它可以成為您自己的“數位孿生體”，供您進行測試。