Многоагентное моделирование ресторана с использованием больших языковых моделей (LLM) на практике с Python и OpenAI

На прошлой неделе OpenAI опубликовал файл PDFИ все об этом говорят. Этот файл представляет собой 34-страничное руководство, объясняющее, что такое агенты большой языковой модели (агенты LLM) и как их использовать.

PDF-файл относительно короткий и его легко читать (вам не нужно быть инженером-программистом/наставником, чтобы понять его), но в нескольких словах он объясняет три вещи:

.1. Агенты большой языковой модели (агенты LLM) «Это системы, которые независимо выполняют задачи от вашего имени».

Так разве это не просто простые вызовы больших языковых моделей (LLM), вызываемые через API? Ну, и да, и нет. Вы используете одну и ту же форму(ы) завершения разговора, так что это что-то вроде того, Но Он предназначен для создания определенного действия. Я имею в виду, что результаты работы ваших агентов Его необходимо преобразовать в действенный результат. В вашей системе. Например, если в выходных данных вашего LLM указано «спагетти», то в ваш путь данных будет добавлено слово «спагетти», и в конечном итоге кто-то его увидит и приготовит спагетти (оповещение).

2. Агенты большой языковой модели (агенты LLM) специально интегрированы с Функции (Инструменты)

Я говорю о сценарии, когда вы задаете ChatGPT вопрос, и он вызывает свой собственный генератор изображений/веб-поисковик/фрагмент кода. Внутри себя он использует функцию, называемую виджетом, которая активируется по вашему запросу. Теперь генератор изображений — это встроенная функция, но они также могут вызывать Ваша работа (ваш инструмент), которые вы можете указать специально для вашей задачи. Эта способность интегрировать внешние инструменты и функции дает агентам LLM большую гибкость и мощь при выполнении различных задач.

 

3. Возможна интеграция нескольких крупных агентов языковой модели (агентов LLM). Последовательный

Вы можете интегрировать одного агента и снабдить его несколькими инструментами. أو Разделим инструменты на специализированные агенты, что мы и сделаем в этой статье (еще одна подсказка!).

Технические подробности могут быть интересны инженерам-программистам, но почему тема агентов так важна для всех остальных?
Ну, потому что это представляет собой смену парадигмы, которая помогает обеспечить полезность моделей открытого ИИ. Подумайте об этом: теперь большие языковые модели (LLM) предоставляют Осуществимые результаты. Таким образом, речь идет не об использовании подсказок LLM на последнем этапе рабочего процесса для улучшения конечного результата; Скорее, речь идет о Интеграция всего рабочего процесса с помощью агентов большой языковой модели (агентов LLM) Улучшить качество всего рабочего процесса.

Хотя я и пытаюсь объяснить это словами, мне кажется, проще показать это на практике. Допустим, мы говорим о ресторан, Например.

В типичном ресторане процесс вполне стандартный и понятный: вы стоите в очереди, заказываете еду, ждете ее, едите и уходите. Теперь, если мы переведем это, используя подход «агент», мы можем выделить по крайней мере трех агентов:

• агент Клиент Это агент большой языковой модели (LLM), который заказывает еду или спрашивает рекомендации у официанта.
• агент официант Это большая языковая модель (LLM), которая собирает запросы и при необходимости дает предложения.
• агент Развлечения Это большая языковая модель (LLM), предназначенная для обработки жалоб клиентов.

OpenAI подскажет вам, как именно создавать эти сущности, но это относительно простая часть; Здесь есть нечто большее, не так ли?

Нам необходимо реализовать ресторан, и нам нужно создать Метод листа ожидания, где люди сидят в зависимости от того, насколько заполнен ресторан, и нам нужно создать меню еды, симуляция وقت الانتظارи убедитесь, что все работает, затем Только тогда Мы можем подключить агентов. как всегда:

 

Генеративный ИИ эффективен, но только если используется в правильном контексте.

Итак, прежде чем мы перейдем к самой захватывающей части об агентах, в этой статье вы увидите:

1. Проектирование системы Для ресторанного агента, магистр права. Идея без кода, просто набросок проекта ручкой и бумагой (или, скорее, мышкой и PowerPoint).
2. Реализация ресторана без агентов. Просто и понятно, просто создайте базовую структуру кода.
3. Реализация Агент Ресторан. Плюс простой графический пользовательский интерфейс для наглядного отображения.
4. Заключительные соображения и наблюдения.

Похоже, нам предстоит многое обсудить. В лабораторию! 🧪

1. Проектирование ресторанной системы: руководство эксперта

Примечание: если вы уже ознакомились с технической стороной вопроса, то эта конструкция системы покажется вам очень простой. Цель этого проекта — не всесторонне продемонстрировать каждую часть системы машинного обучения (как вас просят в 15-минутном интервью 🙃), а просто дать некоторые указания о том, что мы будем делать дальше.

Способ, которым мы можем визуализировать процесс работы ресторана, интегрированный с большой языковой моделью (LLM), представлен на следующем рисунке:

Позвольте мне объяснить:

• Ресторан() и Меню() Их два класса. Мы определяем их, и все таблицы, заказы и системная информация внутри классов будут определяться и обновляться динамически.
• придется Новый клиент Пройдите через механизм сидения. Если они могут сидеть (достаточно свободных столов), это здорово, мы можем позволить им сидеть; В противном случае клиенту придется ждать в очереди.
• Для клиента сидящийТам будет официант, который позволит им заказать еду. Они могут «пожаловаться» и спросить, сколько времени займет приготовление еды после заказа.
• Люди не могут ожидание в очереди Они делают многое, но также могут «жаловаться» и спрашивать, как долго им придется ждать в очереди, прежде чем они смогут сесть.

Теперь, если вы задумаетесь, вы не Необходимость к большой языковой модели (LLM) для этой цели. Например, мы можем заранее рассчитать время ожидания, а затем связать его с заранее определенной отформатированной строкой. Мы также можем использовать простое меню для сбора заказов (как в автоматизированном киоске McDonald's) и на этом закончить. Конечно, мы можем это сделать, но подумайте об этом.

Что делать, если клиент хочет получить информацию о меню? во время ожидания? А что если бы это было так? нерешительный О еде? А что, если они захотят узнать? Самый вкусный вегетарианский вариант В меню? А что, если бы они захотели? Хорошее вино по разумной цене? Мы можем либо начать определять методы на основе правил для каждого из этих сценариев, тратя время и деньги, либо начать использовать искусственный интеллект. Вот об этом и пойдет речь в этой статье. Если мы используем большие агенты языковой модели (агенты LLM), у нас есть возможность обработать все эти сценарии за один проход.

Теперь, если я чему-то и научился, так это тому, что программной инженерией нужно заниматься. Шаг за шагом. Тебе лучше иметь هيكل عظمي Затем добавьте к своей модели украшения и аксессуары. По этой причине мы создадим версию вышеуказанного продукта без агентов. В этой упрощенной версии будет реализована система очередей, которая рассчитывает время ожидания и выполняет меню, поэтому все будет работать гладко без какого-либо искусственного интеллекта. После этого шага мы можем разместить агентов в местах, которые мы обсудили и показали выше (клиент, хозяин и официант).

2. Реализация без агентов

Всегда лучше максимально упростить все в основном сценарии, а сложные операции оставить на втором плане. Нашу реализацию Agent Free можно запустить в этом коде.

импорт случайных чисел импорт времени импорт математики импорт sys из утилит импорт * из констант импорт * из naive_models импорт * если __name__ == "__main__": случайные.seed(42) меню = 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)

Как мы видим, мы можем изменить:

• num_tables; Количество столиков в нашем ресторане.
• вероятность_прибытия; Это вероятность прибытия клиента на каждом временном этапе.
• клещ; Это временной шаг нашего моделирования.
• Пауза; Он реализует функцию time.sleep() и используется для имитации рабочего процесса настоящего ресторана.

Теперь вся эта реализация выполняется в файле. наивные_модели.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, мы получим это из терминала.

Это сам по себе продукт науки о данных. С помощью этого вы можете управлять сетью ресторанов Монте-Карло, вы можете увидеть потенциальную возможность создания длинных очередей, рестораны могут использовать этого «цифрового двойника» своего ресторана и видеть, когда могут произойти критические события. Теперь, когда у нас есть работающий продукт, давайте сделаем его более красивым и мощным, используя искусственный интеллект (ИИ).

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. " "Если клиент задает вам неуместные вопросы, просто выведите формат json 'unsuccessfull' '{food: , статус: }'", tools = [get_menu]) entertainment_agent = Agent(name = "Entertainer", instructions = ("Вы полезный официант, который занимает клиентов, пока они ждут." "Вы не можете предоставить никаких скидок или предложений, но они могут задавать вопросы о меню, которые вы можете получить с помощью функций get_menu. Они также могут спросить вас, как долго будет стоять в очереди, чтобы попасть внутрь. Их информация находится в waiting_time" "Если user_status — 'queue', просто любезно укажите время, исходя из продолжительности ожидания. В противном случае, " "если user_status — 'food', это означает, что они ждут еду. Проверьте 'order' и дайте забавную ссылку на их время ожидания. Например, 'ваше время ожидания пасты — 1 минут, похоже, повар добавляет в нее соус!'", tools = [get_menu]) customer_agent = Agent(name = "Customer", instructions = ("Вы клиент, и вы едите в итальянский ресторан. Посмотрите меню с помощью функции get_menu. Если вы уже знаете, что хотите, просто скажите официанту, что вы хотели бы. " "В противном случае дайте им общее указание или попросите руководства на основе ваших общих предпочтений, и они выберут для вас лучшее."), tools = [get_menu]) def call_agent(runner, msg, class_agent = "wait"): if class_agent == "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.run_sync(customer_agent, '')

У нас есть определение Клиент, который является клиентским вызовом OpenAI, и newtools.py, который вытягивает список, и call_agent который вызывает отдельного агента и управляет им через бегун. Эти компоненты необходимы для создания эффективной агентской системы.

Это именно то, о чем мы говорили во введении. Мы идентифицируем несколько وكلاء Они будут подключены, и они используют أدوات Определено моим кодом. Эти инструменты и агенты позволяют автоматизировать задачи по обслуживанию клиентов и улучшить пользовательский опыт.

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_dict(orient="records")

3.2 Внедрение специализированных агентов

Реализация интегрирована Таблица и Рестораны - Restaurant С агентами в следующем коде:

 

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 Runner # список имен из вашей константы NAMES # предположим, что NAMES = [ ... ] 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(msg) waiting_message = { "customer_id": cid, "customer_name": 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 позаботился о {cname} с помощью этого: {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 t in self.tables if t.cust_id == cid) food = table.plate cname = self.names[cid] msg = f"[{self.clock:04}m] ❓ Клиент {cid}: Сколько времени займет доставка еды?
print(msg) self.log_to_msg(msg) если ожидание равно None: msg = f"[{self.clock:04}m] ➡️ Готово!"
print(msg) self.log_to_msg(msg) else: msg = f"[{self.clock:04}m] ➡️ Расчетное время ожидания еды для клиента {cid}: {wait}m" print(msg) self.log_to_msg(msg) waiting_message = { "customer_id": cid, "customer_name": 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 позаботился о {cname} с помощью этого: {output_llm}" print(msg) self.log_to_msg(msg) 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() free = sum(t.is_free for t in self.tables) msg ​​​​= f"n--- КОНЕЦ СМЕНЫ ---n{free}/{len(self.tables)} таблиц свободно в {self.clock}m."
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, arrive_prob=0.7, tick_length=1, real_pause=5.0, query_prob=0.8, menu=menu ) R.run(total_time=60)

3.3 Реализация графического пользовательского интерфейса (GUI) для ресторана с использованием большой языковой модели (LLM)

Для отображения эффективности работы ресторана с помощью приложения большой языковой модели (LLM) мы будем использовать простой графический пользовательский интерфейс (GUI).

из llm_models_gui импорт RestaurantGUI из utils импорт * импорт random из llm_models импорт Restaurant if __name__ == "__main__": random.seed(42) menu = preprocess_menu(MENU_FILE, eat_time_factor=0.5) R = Restaurant( num_tables=5, Arrival_prob=0.7, tick_length=1, real_pause=1.0, # сглаживание для GUI query_prob=0.8, menu=menu ) app = RestaurantGUI(R)

Графический интерфейс пользователя (GUI) предоставляет вам информацию о человеке (Эмма), таблице, времени и выводе большой языковой модели (LLM). Запись .txt также создается автоматически.

Позвольте мне показать вам пример вывода:

[12:31:23] Клиентка Эмма обращается к официанту: «Я бы хотела начать с брускетты в качестве закуски. Затем я закажу спагетти карбонара в качестве первого блюда. На десерт я бы хотела тирамису. Можете ли вы также порекомендовать вино, которое подойдет к этому блюду?» [12:31:25] Обработанный ответ от нашего студента магистратуры: {'food': ['Bruschetta', 'Spaghetti Carbonara', 'Tiramisu', 'Chianti Classico'], 'status': 'successful'} [12:31:25] [0000M] ❓ Клиент 1: Сколько времени мне понадобится, чтобы приготовить еду? [12:31:25] [0000M] ➡️ Ожидаемое время ожидания еды для клиента 1:15 минуты [12:31:26] Студент LLM выполнил заказ Эммы: Последний клиент: Агент (имя=”Entertainer”, …) Конечный результат (строка): Привет, Эмма! Спасибо за ваше терпение. Время ожидания входа составляет около 15 минут. Мы почти на месте — как раз достаточно времени, чтобы начать мечтать о вкуснейшей брускетте! ???? ️

Мы можем предложить:

1. Клиент формирует свое собственное меню через агента.и просит рекомендацию у агента официанта.
2. Официант рекомендует вино Кьянти и добавляет его в список.
3. Агент по рассмотрению жалоб информирует клиента о сроке ожидания.

Теперь мы не можем просто моделировать рабочий процесс, как мы делали раньше, у нас есть рабочий процесс. Умный, работающий на той же технологии ChatGPT. Разве это не здорово?

 

4. Заключение

Спасибо большое, что пришли, это очень много для меня значит ❤️.
Давайте вернемся и посмотрим, что мы сделали в этой статье.

1. Проектирование ресторанной системы:
   Мы создали быстрый проект ресторанной системы с использованием PowerPoint с добавлением агентов ИИ.
2. На безагентной основе:
   Сначала мы построили детерминированную симуляцию, чтобы иметь возможность закодировать логику очереди, времени приготовления и ротации столов. Это наш скелет до внедрения ИИ.
3. Ресторан, работающий через агента:
   На этом этапе мы использовали агентов ИИ для заполнения нашего дела по жалобе и иску агентами. Мы также создали графический пользовательский интерфейс для наглядного отображения результатов.

Сейчас я хочу внести ясность. Я знаю, это немного напоминает «Черное зеркало». Моделирование клиента? Симулятор ресторана и официанта? Да, это странно, Но Проблема не в инструменте ИИ, а в том, как он используется. Я считаю, что замена официантов-людей на искусственный интеллект — это проигрышная идея.

Работа официанта заключается не только в том, чтобы принимать заказы и рекомендовать вино номер N на основе вин N-1, заказанных ранее. Важно быть достаточно теплым, чтобы гость почувствовал себя желанным гостем, но достаточно отстраненным, чтобы не вмешиваться в его разговор, достаточно мягким, чтобы он чувствовал себя как дома, но достаточно настойчивым, чтобы заставить его уважать ваши границы. Я считаю, что это сочетание качеств, требующих человеческого подхода, терпения и сочувствия.

Однако я считаю, что правильное использование этой технологии может быть двояким:

1. Помощь реальным людям, находящимся в листе ожидания. Официанты внутри очень заняты, а рестораны уже предлагают меню, с которым вы можете ознакомиться, пока ждете свой столик, и нереально думать, что другие официанты развлекают людей, ожидающих без столика. На этом этапе может оказаться полезным общение с искусственным интеллектом.
2. Ресторанная симуляция. Сценарий, который я написал, имитирует Поведение Клиенты также. Это означает, что потенциально вы можете использовать симуляции для тестирования различных сценариев, наблюдения за формированием очередей, прогнозирования различных реакций людей, различных ответов официантов и т. д. Другими словами, это может быть ваш «цифровой близнец», на котором вы проводите тесты.