ИИ-агенты: оптимизация затрат и ресурсов с помощью исследований операций и анализа данных

Планирование затрат и ресурсов для агентов ИИ с использованием четырех распространенных моделей оптимизации.

Делиться

От небольших команд до крупных предприятий, все больше организаций внедряют ИИ-агентов и используют многоагентные архитектуры для предоставления надежных, масштабируемых и управляемых решений. Затраты на ИИ-агентов и LLM могут быстро расти без тщательного управления. В этой статье мы рассмотрим несколько бизнес-задач планирования агентов и оптимизации затрат и представим их в виде решений в рамках исследования операций с точки зрения науки о данных. Если вас интересует более подробная информация о планировании агентов и агентном ИИ, ознакомьтесь с моей статьей «Как создать собственную систему агентного ИИ с помощью CrewAI».

Что такое оптимизация в исследовании операций?

Исследование операций использует математические модели и оптимизацию для поиска оптимального решения в условиях практических ограничений. Оно является основой прескриптивной аналитики, которая преобразует прогнозные данные в действия, имеющие решающее значение для принятия решений. Преобразование реальной ситуации в абстрактную математическую модель — ключ к решению любой задачи исследования операций.

Простой, но широко распространенный пример исследования операций — это задача линейного программирования, в которой мы пытаемся найти значения x и y, которые максимизируют линейное уравнение (например, 2x + 4y) при ограничениях x ≥ 0 и y ≥ 0. Задачи исследования операций обычно включают следующие ключевые компоненты:

1. Переменные решения: переменные, которые необходимо определить.
2. Ограничения: Реальные ограничения на ресурсы или требования.
3. Цели: задача, которую необходимо максимизировать или минимизировать.

Как оптимизировать затраты агентов и распределение ресурсов

Планирование работы ИИ-агентов предполагает принятие решений о распределении ресурсов в рамках бюджета компании при одновременном достижении наилучших возможных результатов, что делает его идеальным инструментом для сценариев исследования операций. Мы можем сопоставить описанные выше основные компоненты с вариантами использования оптимизации затрат на агентов и планирования ресурсов.

• Переменные принятия решений: Агенты распределяют задачи или проекты.
• Ограничения: бюджет, время отклика, токен
• Цели: минимизация затрат, максимизация прибыли от инвестиций.

Для решения распространенных сценариев планирования работы агентов мы будем использовать 4 наиболее распространенных шаблона оптимизации:

• Задача покрытия множества: выбрать наименьшее множество агентов, которое охватывает все необходимые задачи, навыки или бизнес-функции, с целью минимизации затрат без пробелов в возможностях.
• Задача распределения: определить, какой агент должен заниматься каждым проектом, с целью максимизации общей ценности результата.
• Задача о рюкзаке: выбрать наилучший набор агентов при фиксированном бюджете, чтобы максимизировать общее количество полученных токенов.
• Сетевая задача: Разработка рабочих процессов в сети агентов для удовлетворения потребностей отделов и пользователей с минимальными затратами при ограниченных возможностях.

Для большей практичности мы рассмотрим четыре примера на Python с использованием библиотеки Gurobi. Gurobi — это математическая оптимизационная программа корпоративного уровня, поддерживающая множество типов задач, включая линейное программирование и смешанное целочисленное программирование. Она часто используется в качестве «движка решения» в приложениях исследования операций, поскольку может эффективно обрабатывать крупномасштабные модели и предоставляет надежные API, включая Python, для определения переменных решения, ограничений и целевых функций. Gurobi позволяет специалистам по анализу данных сосредоточиться на моделировании, а не на реализации пользовательских алгоритмов оптимизации. Обратите внимание, что эта статья не связана с Gurobi, и все упомянутые здесь функции могут быть реализованы с использованием бесплатной лицензии. Все наборы данных, показанные в этом проекте, являются синтетическими и используются для демонстрации концепции.

1. Задача покрытия множества – Покрытие навыков агента

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

Постановка задачи: Компания хочет внедрить агентов в повседневную работу и охватить девять областей навыков, перечисленных в таблице «Области навыков» ниже. Создание каждого агента обходится в 20 000 долларов и специализируется на определенном наборе навыков, как показано в таблице «Навыки агента». Как компания может минимизировать общие затраты на создание агентов, сохраняя при этом охват всех областей?

Область навыков

Навыки агента

Выполнение

Мы можем сформулировать это как задачу оптимизации, которая следует шаблону покрытия множества, и решить ее с помощью библиотеки Gurobi, определяемой следующими ключевыми компонентами: данные, модель, переменные, ограничения и целевые функции.

• Данные: загрузите данные о навыках, агентах и стоимости услуг агентов (которая составляет 20 000 за каждого агента).

 ## data skills = data["skills"] agents = data["agents"] agent_skills = data["agent_skills"] agent_costs = {i: 20 for i in agents}

• Модель: Создайте модель Gurobi с именем «Set Covering». Если вы еще не установили gurobipy, выполните команду.

 ## model import gurobipy as gp model = gp.Model("Set Covering")

• Переменные: Переменные решения — это бинарные переменные, связанные с каждым агентом, с нижней границей 0 и верхней границей 1, указывающими на то, выбран ли агент. Gurobi предлагает ряд предустановленных типов переменных, включая GRB.BINARY , GRB.INTEGER , GRB.CONTINUOUS и т. д.

 ## variables X = model.addVars(agents, lb=0, ub=1, vtype=GRB.BINARY, name="x")

• Ограничения: Для каждой области навыков сумма всех выбранных агентов, обладающих этим навыком, должна быть больше 1, что гарантирует наличие как минимум одного агента, охватывающего данную область навыков. Мы используем функцию суммирования gp.quicksum для добавления ограничений с помощью взвешенной суммы, а затем используем выражения вложенных циклов для итерации по девяти областям навыков.

 ## constraints: for each skill in skills, sum of agents with that skill ≥ 1 for j in skills: model.addConstr( gp.quicksum(X[i] for i in agents if j in agent_skills[i]) >= 1, name=f'{j}_area_constr' )

• Цель: Минимизировать общую стоимость выбранных агентов, рассчитываемую как взвешенная сумма стоимости каждого агента, умноженная на переменную решения, указывающую, выбран ли данный агент.

 ## objectives: minimize sum of agents selected model.setObjective( gp.quicksum(agent_costs[i] * X[i] for i in agents), GRB.MINIMIZE )

Наконец, мы запускаем оптимизацию модели, используя model.optimize() .

Влияние на бизнес

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

Оптимальный результат

model.ObjVal выводит оптимальное значение целевой функции. Для каждой бинарной переменной решения мы используем X[i].X > 0.5 для вывода выбранных агентов.

 print(f"Total agents selected: {round(model.ObjVal, 4)}") for i in agents: if X[i].X > 0.5: print(f"Agent {i} selected.")

В качестве альтернативы, Claude Code предлагает мне следующий фрагмент кода для структурированного отображения результатов работы модели.

 print("================ Set-Covering: Skill Coverage ================") if model.Status == GRB.OPTIMAL: selected = [i for i in agents if X[i].X > 0.5] print(f"Minimum agents needed : {len(selected)}") print(f"Total cost : ${model.ObjVal:.0f}k") print("nSelected agents:") for agent in selected: covered = ", ".join( f"{s}({skill_labels[s]})" for s in agent_skills[agent] ) print(f" - {agent} [{covered}]") else: print("No optimal solution found.")

Приведенные ниже результаты показывают, что оптимальное планирование работы агентов заключается в выборе 4 агентов (агент общей поддержки, агент доступа и разрешений, агент CRM и агент оптимизации затрат и производительности) для охвата всех навыков при бюджете в 80 000 долларов.

 ================ Set-Covering: Skill Coverage ================ Minimum agents needed : 4 Total cost : $80k Selected agents: - General Support Agent [F(Support), C(Knowledge), H(Collaboration)] - Access & Permissions Agent [F(Support), E(Automation), G(Governance)] - CRM / Relationship Management Agent [A(Planning), B(Tool Use), C(Knowledge)] - Cost & Performance Optimization Agent [D(Analytics), I(Monitoring), J(Optimization)]

Моделирование

Затем мы смоделировали случайный выбор и сравнили его с оптимальным результатом. Как показано ниже, мы сгенерировали 500 возможных вариантов выбора агентов (синяя гистограмма) со стоимостью от 80 000 до 200 000 долларов и средней стоимостью 134 600 долларов (синяя пунктирная линия). Это означает, что оптимизация помогает бизнесу снизить затраты в среднем на (134 600 долларов − 80 000 долларов) / 134 600 долларов = 40,6%.

 ────────────────────────────────────────────────── Set Covering — Skill Coverage ────────────────────────────────────────────────── Minimum (Optimal) : 80.00 k$ Sim mean : 132.88 k$ Sim min : 80.00 k$ Sim max : 220.00 k$ Feasible solutions : 500/500 ──────────────────────────────────────────────────

Ознакомьтесь с полной реализацией в нашем репозитории на GitHub.

Посмотрите моё видео, если вам интересно узнать больше о создании собственной системы Agentic AI.

2. Задача назначения – Распределение ресурсов агентами

Задача о назначении задач подчиняется распространенной схеме сопоставления задач с людьми или объектами , обычно по принципу «один к одному» или «один ко многим», с целью максимизации выпускаемой продукции или минимизации затрат . Распределение ресурсов агентами соответствует этой схеме, поскольку требует распределения набора агентов между проектами, как правило, с ограничением, что каждый проект должен быть сопоставлен с одним основным агентом, и целью достижения наибольшей общей стоимости выпускаемой продукции.

Постановка задачи: Компания создала набор агентов для работы над 9 проектами, и для каждого проекта требуется назначить одного основного агента. В таблице ниже показан вклад каждого агента в каждый проект. Как компания может максимизировать общую ценность, назначая наиболее подходящего основного агента для каждого проекта?

Выполнение

Для решения этой задачи мы используем тот же шестиэтапный процесс.

• Данные: загрузите данные об агентах, проектах и значениях. Создайте словарь value_map для представления связи между агентом и проектом.

 ## data agents = data["agents"] projects = data["projects"] values = data["values"] # Build value lookup: (agent, project) -> score value_map = { (agents[i], projects[j]): values[i][j] for i in range(len(agents)) for j in range(len(projects)) }

• Модель: Создайте модель Gurobi с именем «Assignment».

 ## model import gurobipy as gp model = gp.Model("Assignment")

• Переменные: В данной задаче переменные решения должны указывать, назначен ли агент на проект, что представляет собой бинарную переменную, связанную с каждой уникальной комбинацией агента и проекта.

 ## variables from gurobipy import GRB X = model.addVars(agents, projects, lb=0, ub=1, vtype=GRB.BINARY, name="x")

• Ограничения: Для каждого проекта сумма всех назначенных агентов должна быть равна единице. Для каждого агента сумма проектов, к которым он назначен, должна быть не менее единицы.

 ## constraints: each project is assigned exactly one agent for j in projects: model.addConstr( gp.quicksum(X[(i, j)] for i in agents) == 1, name=f"{j}_project_constr", ) ## constraints: each agent is assigned at least one project for i in agents: model.addConstr( gp.quicksum(X[(i, j)] for j in projects) >= 1, name=f"{i}_agent_constr", )

• Цель: Максимизировать общий балл, используя сумму баллов каждого агента по каждому проекту, умноженную на переменную решения, указывающую, назначен ли агент на данный проект.

 ## objective: maximize the overall value score model.setObjective( gp.quicksum(value_map[(i, j)] * X[(i, j)] for i in agents for j in projects), GRB.MAXIMIZE, )

Влияние на бизнес

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

Чтобы понять влияние этого сценария оптимизации на бизнес, мы сначала проанализируем рекомендуемое распределение после запуска функции model.optimize() , а затем оценим влияние на общий показатель ценности, сравнив оптимальный результат со случайным распределением.

Оптимальный результат

model.ObjVal выводит оптимальное значение целевой функции. Для каждой бинарной переменной, указывающей на распределение агентов, мы используем X[i, j].X > 0.5 чтобы проверить, назначен ли агент i проекту j.

 print(f"Total value: {round(model.ObjVal, 4)}") for i in agents: for j in projects: if X[(i, j)].X > 0.5: print(f"Agent {i} should be allocated to Project {j}.")

ИЛИ используйте следующий фрагмент кода для более подробного отображения результатов работы модели.

 print("================ Assignment Problem: Resource Allocation ================") if model.Status == GRB.OPTIMAL: print(f"Maximum total suitability score: {model.ObjVal:.0f}n") print(f"{'Agent':<45} {'Project':<6} {'Description':<30} {'Score'}") print("-" * 95) for i in agents: for j in projects: if X[(i, j)].X > 0.5: print( f"{i:<45} {j:<6} {project_labels[j]:<30} {obj_coeffs[(i, j)]}"

Приведенные ниже результаты показывают оптимальное распределение ресурсов, при котором каждому проекту назначается один основной агент, а общий показатель пригодности составляет 77.

 ================ Assignment Problem: Resource Allocation ================ Maximum total suitability score: 77 Agent Project Description Score ----------------------------------------------------------------------------------------------- Analytics & Insights Agent P1 Exec Metrics Dashboard 9 Analytics & Insights Agent P7 Churn Risk Monitor 8 Knowledge Management Agent P8 Onboarding Guide Bot 9 Marketing Campaign Orchestration Agent P3 Lead-Scoring Model 9 Marketing Campaign Orchestration Agent P6 Feature Launch Brief 8 Customer Support Automation Agent P2 CX Knowledge Bot 9 Data Quality & Monitoring Agent P9 SLA Incident Triage 8 Workflow Orchestration Agent P5 Experiment Analysis 8 Governance & Compliance Agent P4 Policy QA Assistant 9

Моделирование

Мы смоделировали 500 случайных, допустимых вариантов распределения агентов и сравнили их с оптимальным результатом, где оценка ценности равна 77. Как показано ниже, 500 допустимых вариантов распределения дали общие оценки ценности в диапазоне от 55 до 72, со средним значением 63,16. Это указывает на то, что оптимизация улучшает оценки ценности в среднем на (77 − 63,16) / 63,16 = 21,9%.

 ────────────────────────────────────────────────── Assignment — Agent-to-Project Allocation ────────────────────────────────────────────────── Maximum (Optimal) : 77.00 score Sim mean : 63.16 score Sim min : 55.00 score Sim max : 72.00 score Feasible solutions : 500/500 ──────────────────────────────────────────────────

3. Задача о рюкзаке – Бюджетирование агентов

Задача о рюкзаке — это задача оптимизации, в которой мы выбираем наилучшую комбинацию предметов, оставаясь в рамках ограничений, таких как бюджет или вместимость . Управление портфелем и организация логистики являются популярными примерами из реальной жизни. Она подходит для сценариев распределения бюджета агентов, где необходимо максимизировать производительность агентов при ограниченном бюджете компании.

Постановка задачи: Имея ежемесячный бюджет в 4000 долларов, выберите агентов из приведенного ниже списка, каждый с фиксированной ежемесячной платой, чтобы максимизировать общее количество сгенерированных токенов.

Выполнение

И снова воспользуйтесь шестиэтапным процессом, чтобы разбить задачу о рюкзаке на части.

• Данные: загрузите список агентов, ежемесячную стоимость услуг каждого агента и количество токенов, выдаваемых каждым агентом, а также фиксированный ежемесячный бюджет в размере 4000 долларов.

 ## data agents = data["agents"] N = range(len(agents)) # number of agents C = data["costs"] # cost per agent P = data["tokens"] # tokens per agent K = 4000 # $4000 monthly budget

• Модель: Создайте модель Gurobi с именем «Рюкзак».

 ## model import gurobipy as gp model = gp.Model("Knapsack")

• Переменные: Каждому агенту присваивается бинарная переменная, указывающая, будет ли он выбран.

 ## variables X = model.addVars(N, lb=0, ub=1, vtype=GRB.BINARY, name="x")

• Ограничения: Общие затраты на всех выбранных агентов не должны превышать бюджет K.

 ## constraint: total cost must not exceed budget model.addConstr( gp.quicksum(C[i] * X[i] for i in N) <= K, name="budget_constr", )

• Цель: Максимизировать общее количество токенов, сгенерированных всеми выбранными агентами.

 ## objective: maximize total tokens generated model.setObjective( gp.quicksum(C[i] * X[i] for i in N), GRD.MAXIMIZE, )

Влияние на бизнес

Этот тип задач оптимизации широко используется в бизнесе, поскольку помогает максимизировать объем производства при фиксированном бюджете. Мы сравним оптимизированные результаты с результатами 500 случайных выборов агентов при тех же бюджетных ограничениях.

Оптимальный результат

После выполнения функции model.optimize() мы используем model.ObjVal для получения оптимального значения целевой функции из общего количества сгенерированных токенов. Для каждой бинарной переменной решения мы используем X[i].X > 0.5 чтобы проверить, выбран ли агент i.

 print(f"Total tokens generated: {round(model.ObjVal, 4)}") for agent in N: if X[agent].X > 0.5: print(f"Agent {agent} selected.")

Результаты работы модели предлагают выбрать 4 агента (классификатор намерений, проверка инвентаря, анализ отзывов и аналитический репортер), которые позволят нам сгенерировать максимальное количество токенов (например, 215 миллионов токенов) в рамках ежемесячного бюджета в 4000 долларов.

 ================ Knapsack Problem: Budgeting ================ Budget : $4,000 Total cost used : $4,000 Total tokens (M) : 215 Agent Cost ($) Tokens (M) ------------------------------------------------------- Intent Classifier 800 50 Inventory Checker 1,200 70 Review Analyzer 900 45 Analytics Reporter 1,100 50 ------------------------------------------------------- TOTAL 4,000 215

Моделирование

Мы смоделировали 500 случайных, допустимых распределений агентов при том же бюджете в 4000 долларов и сравнили их с оптимальным результатом в 215 миллионов токенов. В этих симуляциях общее количество токенов варьировалось от 50 до 215 миллионов, в среднем составляя 151,61 миллиона, что показывает, что оптимизированный план работает примерно на (215 − 151,61) / 151,61 = 41,8% лучше, чем среднее случайное распределение.

 ────────────────────────────────────────────────── Knapsack — Agent Budget Selection ────────────────────────────────────────────────── Maximum (Optimal) : 215.00 tokens (M) Sim mean : 151.61 tokens (M) Sim min : 50.00 tokens (M) Sim max : 215.00 tokens (M) Feasible solutions : 500/500 ──────────────────────────────────────────────────

4. Проблема сети – Маршрутизация агентов

Наконец, мы обсудим сетевую проблему, которая рассматривает сценарии, требующие балансировки спроса и предложения, или входных и выходных данных для совокупности объектов. Например, она включает в себя перемещение запасов по сети складов с наименьшими затратами при соблюдении пропускной способности. Направленный ациклический граф (DAG) — это распространенная графическая модель для сетевых проблем, где узлы представляют собой отдельные объекты, а дуги — потоки от входного объекта к выходному. Критически важным ограничением в сетевой проблеме является то, что каждый узел удовлетворяет требованию «предложение + приток = спрос + отток», то есть чистый поток равен спросу минус предложение.

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

Постановка задачи: Компания использует многоагентную архитектуру, включающую агента по программированию и агента по написанию текстов, а также два координационных центра. Отделам ИТ, маркетинга и операционной деятельности требуется выполнить определенное количество запросов в месяц, как показано в таблице ниже. Хотя отделы могут напрямую взаимодействовать с двумя агентами, это обычно влечет за собой более высокие затраты на каждый запрос. Маршрутизация запросов через координационные центры снижает затраты за счет стандартизации протокола связи. Каждый канал также имеет максимальную ежемесячную пропускную способность по запросам, как указано в таблице ниже. Какой наиболее экономически эффективный способ маршрутизации 12 000 запросов от агента по программированию и агента по написанию текстов в отделы маркетинга, ИТ и операционной деятельности?

Спрос и предложение

Стоимость маршрутизации / Пропускная способность

Выполнение

• Данные: Загрузите данные о мощностях снабжения агентов и запросах отделов, а также о стоимости и пропускной способности каждого пути от агента к хабу или напрямую к отделу.

 ## data nodes = data["nodes"] supplies = data["supplies"] demands = data["demands"] arcs = [(a, b) for a, b, _, __ in data["arcs"]] costs = {(a, b): c for a, b, c, __ in data["arcs"]} capacities = {(a, b): cap for a, b, _, cap in data["arcs"]}

• Модель: Создайте модель Gurobi с именем «Network».

 ## model import gurobipy as gp model = gp.Model("Network")

• Переменные: Определите непрерывную переменную для каждой дуги, представляющую количество запросов, поступающих от одного узла к другому, с верхней границей, равной пропускной способности дуги.

 ## variables X = model.addVars(arcs, lb=0, ub=capacities, vtype=GRB.CONTINUOUS, name="x")

• Ограничения: Для каждого узла (включая агентов, центры агентов и отделы) сумма запросов на поставку и приток должна равняться сумме запросов на спрос и отток.

 ## constraints: flow balance at each node for i in nodes: model.addConstr( supplies[i] + gp.quicksum(X[(j, i)] for j in nodes if (j, i) in arcs) == demands[i] + gp.quicksum(X[(i, j)] for j in nodes if (i, j) in arcs), name=f"{i}_balance_constr", )

• Цель: Минимизировать общую стоимость всех запросов от агента к центру обработки запросов или непосредственно в отдел.

 ## objective: minimize total routing cost model.setObjective( gp.quicksum(costs[(i, j)] * X[(i, j)] for i, j in arcs), GRB.MINIMIZE, )

Влияние на бизнес

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

Оптимальный результат

Мы используем model.ObjVal для получения оптимального значения целевой функции для общей стоимости. Затем мы используем X[(i,j)].X для вывода количества запросов, поступающих от каждого входного узла к каждому выходному узлу.

 print(f"Total Cost: {round(model.ObjVal, 2)}") for (i,j) in arcs: if X[(i,j)].X > 0: print(f"Send {X[(i,j)].X} units of flow on the arc from {i} to {j}")

Как показано в приведенных ниже результатах, оптимальное решение обходится в 5630 долларов в месяц для выполнения 12 000 запросов, поступающих от отделов маркетинга, ИТ и операционной деятельности.

 ================ Network Routing Problem: Agent Routing ================ Minimum total routing cost: $5,630.00 Arc Flow Cap Cost/req Total Cost ------------------------------------------------------------------------------------- Coding Agent -> Marketing Dept 1500 2000 0.80 1,200.00 Coding Agent -> IT Dept 2000 2000 0.60 1,200.00 Coding Agent -> Operations Dept 1200 1200 0.30 360.00 Coding Agent -> Relay Hub A 1200 1500 0.30 360.00 Coding Agent -> Relay Hub B 600 1200 0.20 120.00 Writing Agent -> Marketing Dept 2000 2000 0.50 1,000.00 Writing Agent -> IT Dept 1000 1000 0.20 200.00 Writing Agent -> Operations Dept 1000 1000 0.20 200.00 Writing Agent -> Relay Hub A 300 2000 0.40 120.00 Writing Agent -> Relay Hub B 1200 1200 0.20 240.00 Relay Hub A -> Marketing Dept 1500 1500 0.30 450.00 Relay Hub B -> IT Dept 1000 1000 0.10 100.00 Relay Hub B -> Operations Dept 800 1000 0.10 80.00 Demand fulfillment: Marketing Dept: received 5000 / needed 5000 IT Dept: received 4000 / needed 4000 Operations Dept: received 3000 / needed 3000

Моделирование

После проверки 500 возможных решений с маршрутизацией запросов случайным образом от агентов к отделам, мы можем оценить, что оптимальный результат снижает затраты в среднем на 33% (8425,98 долл. США − 5630,00 долл. США = 2795,98 долл. США).

 ────────────────────────────────────────────────── Network — Agent Routing ────────────────────────────────────────────────── Minimum (Optimal) : $5,630.00 Sim mean : $8,425.98 Sim min : $5,750.00 Sim max : $11,150.00 Feasible solutions : 500/500 ──────────────────────────────────────────────────

Главный вывод

В этой статье мы рассматриваем четыре распространенных шаблона оптимизации в исследовании операций и их практическое влияние на бизнес, используя сценарии планирования с помощью агентов искусственного интеллекта:

• Охват группы: Выберите наименьший набор агентов, который по-прежнему охватывает все необходимые задачи, навыки или бизнес-функции, с целью минимизации затрат без создания пробелов в компетенциях.
• Задание: Определите, какой агент должен заниматься каждым проектом, с целью максимизации общей ценности результата.
• Рюкзак: Выберите оптимальный набор агентов или функций в рамках фиксированного бюджета, чтобы максимизировать общее количество полученных токенов.
• Сеть: Разработка рабочих процессов в сети агентов для удовлетворения потребностей отделов и пользователей с минимальными затратами при ограниченных возможностях.

Сложное планирование работы агентов становится управляемым, если его представить в виде стандартной оптимизационной модели с переменными, ограничениями и целевой функцией. Современные решатели, такие как Gurobi, могут быстро находить оптимальные решения, которые значительно сокращают затраты или увеличивают рентабельность инвестиций.

Другие подобные ресурсы

Destin Gong. Посмотреть все материалы от Destin Gong.

Источник: towardsdatascience.com