智能驱动供应链：强化学习的革新应用优化效率与成本降低

上进小菜猪2024-02-27 13:51

智能驱动供应链：强化学习的革新应用优化效率与成本降低

人工智能（AI）在不同领域中的应用日益广泛，其中强化学习（Reinforcement Learning，RL）作为一种强大的学习范式，正在为供应链管理带来革命性的变化。供应链是企业运作中至关重要的一环，涉及到产品生产、库存管理、物流运输等多个方面。通过引入强化学习，企业能够更有效地应对不断变化的市场需求，优化运营流程，降低成本，提高整体效益。

强化学习简介

强化学习是一种通过智能体与环境的交互学习，通过试错来最大化累积奖励的机器学习方法。在供应链管理中，这意味着我们可以通过模拟不同的决策场景，让系统自动学习如何做出最优决策，以实现供应链的最佳运作。

强化学习在供应链管理中的应用

库存管理

强化学习可以应用于库存管理中，通过考虑需求的波动、供应链延迟等因素，优化库存水平。下面是一个简单的强化学习库存管理的代码示例，使用深度强化学习框架如TensorFlow或PyTorch：

ini 复制代码 
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
​
# 定义强化学习智能体
class InventoryAgent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.model = self.build_model()
​
    def build_model(self):
        model = Sequential()
        model.add(Dense(24, input_dim=self.state_size, activation='relu'))
        model.add(Dense(24, activation='relu'))
        model.add(Dense(self.action_size, activation='linear'))
        model.compile(loss='mse', optimizer='adam')
        return model
​
    def act(self, state):
        return np.argmax(self.model.predict(state))
​
# 模拟环境和训练过程
state_size = 5  # 例如，考虑当前库存、订单量、供应链延迟等状态
action_size = 3  # 例如，采购更多库存、维持现有库存、减少库存
agent = InventoryAgent(state_size, action_size)
​
# 模拟强化学习训练
for episode in range(num_episodes):
    state = env.reset()
    for step in range(max_steps):
        action = agent.act(state)
        next_state, reward, done, _ = env.step(action)
        # 根据反馈更新智能体模型
        agent.train(state, action, reward, next_state, done)
        state = next_state
        if done:
            break

运输与配送优化

强化学习还可以用于优化物流和配送过程。通过考虑不同路径、运输方式、交通状况等因素，系统可以学习如何调整运输计划以最大化效益。

当涉及强化学习在供应链管理中的具体应用时，一个常见的场景是在库存管理中使用强化学习来决定何时下订单以及订单的数量。以下是一个简单的Q学习算法的代码案例，演示了在库存管理中如何使用强化学习：

ini 复制代码 
import numpy as np
​
class InventoryManagementAgent:
    def __init__(self, n_actions, n_states, learning_rate=0.1, discount_factor=0.9, exploration_prob=0.2):
        self.n_actions = n_actions
        self.n_states = n_states
        self.learning_rate = learning_rate
        self.discount_factor = discount_factor
        self.exploration_prob = exploration_prob
        self.q_table = np.zeros((n_states, n_actions))
​
    def select_action(self, state):
        if np.random.rand() < self.exploration_prob:
            return np.random.choice(self.n_actions)
        else:
            return np.argmax(self.q_table[state, :])
​
    def update_q_table(self, state, action, reward, next_state):
        best_next_action = np.argmax(self.q_table[next_state, :])
        self.q_table[state, action] += self.learning_rate * \
            (reward + self.discount_factor * self.q_table[next_state, best_next_action] - self.q_table[state, action])
​
# 模拟环境
class InventoryEnvironment:
    def __init__(self, initial_inventory, max_inventory, demand_distribution, holding_cost, ordering_cost):
        self.initial_inventory = initial_inventory
        self.inventory = initial_inventory
        self.max_inventory = max_inventory
        self.demand_distribution = demand_distribution
        self.holding_cost = holding_cost
        self.ordering_cost = ordering_cost
​
    def reset(self):
        self.inventory = self.initial_inventory
​
    def step(self, action):
        # 模拟库存管理过程
        demand = np.random.choice(self.demand_distribution)
        order_quantity = action
​
        # 计算奖励
        holding_cost = self.holding_cost * max(0, self.inventory - demand)
        ordering_cost = self.ordering_cost * order_quantity
        reward = -holding_cost - ordering_cost
​
        # 更新库存
        self.inventory = max(0, min(self.max_inventory, self.inventory - demand + order_quantity))
​
        # 返回下一个状态（库存水平）
        next_state = self.inventory
​
        return next_state, reward
​
# 设置参数
n_actions = 5  # 订单数量的离散选择
n_states = 100  # 库存水平的离散状态
learning_rate = 0.1
discount_factor = 0.9
exploration_prob = 0.1
num_episodes = 1000
​
# 初始化代理和环境
agent = InventoryManagementAgent(n_actions, n_states, learning_rate, discount_factor, exploration_prob)
env = InventoryEnvironment(initial_inventory=50, max_inventory=100, demand_distribution=[10, 20, 30], holding
​
成本=1, ordering_cost=5)
​
# 训练代理
for episode in range(num_episodes):
    state = env.reset()
    total_reward = 0
​
    for step in range(50):  # 最大步数，避免无限循环
        action = agent.select_action(state)
        next_state, reward = env.step(action)
        agent.update_q_table(state, action, reward, next_state)
​
        total_reward += reward
        state = next_state
​
    if episode % 100 == 0:
        print(f"Episode {episode}, Total Reward: {total_reward}")
​
# 测试代理
test_episodes = 10
avg_test_reward = 0
​
for episode in range(test_episodes):
    state = env.reset()
    total_reward = 0
​
    for step in range(50):  # 最大步数，避免无限循环
        action = agent.select_action(state)
        next_state, reward = env.step(action)
​
        total_reward += reward
        state = next_state
​
    avg_test_reward += total_reward
​
avg_test_reward /= test_episodes
print(f"Avg Test Reward: {avg_test_reward}")

这个简单的代码演示了一个基于Q学习的库存管理代理。在实际应用中，可以根据具体情况进行更复杂的模型设计和调整参数。这个例子提供了一个基本的框架，供参考和进一步拓展。

深度强化学习（Deep Reinforcement Learning，DRL）

下面是一个使用深度强化学习（Deep Reinforcement Learning，DRL）的案例，其中代理利用深度神经网络来学习库存管理策略。我们将使用OpenAI的Gym库来创建库存管理环境，以及TensorFlow和Keras来构建深度Q网络。

ini 复制代码 
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
import gym
​
# 创建库存管理环境
class InventoryEnvironment(gym.Env):
    def __init__(self, initial_inventory=50, max_inventory=100, demand_distribution=[10, 20, 30], holding_cost=1, ordering_cost=5):
        super(InventoryEnvironment, self).__init__()
​
        self.initial_inventory = initial_inventory
        self.inventory = initial_inventory
        self.max_inventory = max_inventory
        self.demand_distribution = demand_distribution
        self.holding_cost = holding_cost
        self.ordering_cost = ordering_cost
​
        self.action_space = gym.spaces.Discrete(6)  # 0 to 5, representing order quantity
        self.observation_space = gym.spaces.Box(low=0, high=max_inventory, shape=(1,), dtype=np.float32)
​
    def reset(self):
        self.inventory = self.initial_inventory
        return np.array([self.inventory])
​
    def step(self, action):
        demand = np.random.choice(self.demand_distribution)
        order_quantity = action
​
        holding_cost = self.holding_cost * max(0, self.inventory - demand)
        ordering_cost = self.ordering_cost * order_quantity
        reward = -holding_cost - ordering_cost
​
        self.inventory = max(0, min(self.max_inventory, self.inventory - demand + order_quantity))
​
        next_state = np.array([self.inventory])
        return next_state, reward, False, {}  # The last value indicates if the episode is done (always False here)
​
# 创建深度Q网络代理
class DQNAgent:
    def __init__(self, state_size, action_size, learning_rate=0.001, discount_factor=0.9, exploration_prob=0.2):
        self.state_size = state_size
        self.action_size = action_size
        self.learning_rate = learning_rate
        self.discount_factor = discount_factor
        self.exploration_prob = exploration_prob
​
        self.model = self.build_model()
        self.target_model = self.build_model()
        self.update_target_model()
​
    def build_model(self):
        model = Sequential()
        model.add(Dense(24, input_dim=self.state_size, activation='relu'))
        model.add(Dense(24, activation='relu'))
        model.add(Dense(self.action_size, activation='linear'))
        model.compile(loss='mse', optimizer=Adam(lr=self.learning_rate))
        return model
​
    def update_target_model(self):
        self.target_model.set_weights(self.model.get_weights())
​
    def select_action(self, state):
        if np.random.rand() < self.exploration_prob:
            return np.random.choice(self.action_size)
        else:
            q_values = self.model.predict(state)
            return np.argmax(q_values[0])
​
    def train(self, state, action, reward, next_state, done):
        target = self.model.predict(state)
        if done:
            target[0][action] = reward
        else:
            target_next = self.target_model.predict(next_state)[0]
            target[0][action] = reward + self.discount_factor * np.amax(target_next)
​
        self.model.fit(state, target, epochs=1, verbose=0)
​
        if done:
            self.update_target_model()
​
# 训练代理
env = InventoryEnvironment()
state_size = env.observation_space.shape[0]
action_size = env.action_space.n
agent = DQNAgent(state_size, action_size)
​
num_episodes = 1000
for episode in range(num_episodes):
    state = env.reset()
    state = np.reshape(state, [1, state_size])
    total_reward = 0
​
    for step in range(50):  # 最大步数，避免无限循环
        action = agent.select_action(state)
        next_state, reward, done, _ = env.step(action)
        next_state = np.reshape(next_state, [1, state_size])
        agent.train(state, action, reward, next_state, done)
​
        total_reward += reward
        state = next_state
​
        if done:
            break
​
    if episode % 100 == 0:
        print(f"Episode {episode}, Total Reward: {total_reward}")
​
# 测试代理
test_episodes = 10
avg_test_reward = 0
​
for episode in range(test_episodes):
    state = env.reset()
    state = np.reshape(state, [1, state_size])
    total_reward = 0
​
    for step in range(50):  # 最大步数，避免无限循环
        action = agent.select_action(state)
        next_state, reward, done, _ = env.step(action)
        next_state = np.reshape(next_state, [1, state_size])
​
        total_reward += reward
        state = next_state
​
        if done:
            break
​
    avg_test_reward += total_reward
​
avg_test_reward /= test_episodes
print(f"Avg Test Reward: {avg_test_reward}")

这个例子演示了如何使用深度Q网络代理在库存管理环境中进行训练和测试。在实际应用中，你可能需要调整网络架构、超参数，并根据具体问题进行更复杂的模型设计。

这段代码实现了一个库存管理问题的深度 Q 网络代理，使用强化学习进行训练，并在测试阶段评估代理性能。下面是代码的解析：

  1. 导入库和模块:

    • numpy 用于数值操作。
    • tensorflow 是深度学习框架。
    • gym 是用于开发强化学习环境的工具。
javascript 复制代码 
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
import gym

  1. 定义库存管理环境类 (InventoryEnvironment) :

    • 这是一个 OpenAI Gym 的环境类，模拟了库存管理的问题。具体来说，它有一个离散的动作空间和一个连续的观察空间。
    • step 方法模拟了环境中的一步操作，接受代理的动作，返回下一个状态、奖励、以及一个指示是否结束的标志。
    • reset 方法用于重置环境的状态。
ruby 复制代码 
class InventoryEnvironment(gym.Env):
    def __init__(self, initial_inventory=50, max_inventory=100, demand_distribution=[10, 20, 30], holding_cost=1, ordering_cost=5):
        # ...
​
    def reset(self):
        # ...
​
    def step(self, action):
        # ...

  1. 定义深度 Q 网络代理类 (DQNAgent) :

    • 代理具有两个神经网络模型，一个用于学习，另一个用于固定目标。这是深度 Q 网络（DQN）的一种经典结构。
    • select_action 方法用于选择动作，可以进行探索（以一定概率选择随机动作）或利用（选择具有最大 Q 值的动作）。
    • train 方法用于训练代理，更新 Q 值。在每个步骤结束后，如果 done 为真，表示一个 episode 结束，会更新目标模型的权重。
ruby 复制代码 
class DQNAgent:
    def __init__(self, state_size, action_size, learning_rate=0.001, discount_factor=0.9, exploration_prob=0.2):
        # ...
​
    def build_model(self):
        # ...
​
    def update_target_model(self):
        # ...
​
    def select_action(self, state):
        # ...
​
    def train(self, state, action, reward, next_state, done):
        # ...

  1. 训练代理:

    • 使用环境类和代理类，循环进行一定数量的 episodes，每个 episode 中，代理与环境交互，选择动作，接收奖励，更新模型。
ini 复制代码 
env = InventoryEnvironment()
state_size = env.observation_space.shape[0]
action_size = env.action_space.n
agent = DQNAgent(state_size, action_size)
​
num_episodes = 1000
for episode in range(num_episodes):
    # ...
​
    for step in range(50):
        # ...
        agent.train(state, action, reward, next_state, done)
​
        if done:
            break
​
    if episode % 100 == 0:
        print(f"Episode {episode}, Total Reward: {total_reward}")

  1. 测试代理:

    • 在一定数量的测试 episodes 中，测试代理的性能，并计算平均测试奖励。
python 复制代码 
test_episodes = 10
avg_test_reward = 0
​
for episode in range(test_episodes):
    # ...
​
    for step in range(50):
        # ...
​
        if done:
            break
​
    avg_test_reward += total_reward
​
avg_test_reward /= test_episodes
print(f"Avg Test Reward: {avg_test_reward}")

这个代码示例演示了如何使用深度 Q 网络（DQN）和强化学习来解决库存管理问题，通过不断与环境交互，代理学会在不同状态下选择合适的动作以最大化累积奖励。

强化学习在供应链管理中的优势

适应性

强化学习系统通过与环境的交互学习，能够适应不断变化的市场需求和供应链条件。这种适应性使得系统能够更好地处理不确定性，对新的情况做出智能决策。

最大化长期利益

传统的供应链管理方法可能侧重于短期利润最大化，而强化学习注重长期利益的最大化。通过考虑未来的累积奖励，系统能够制定更为长远的策略，使得企业在竞争中更具竞争力。

数据驱动决策

强化学习模型基于数据和环境的交互进行训练，能够从大量的实际操作中学到最佳的决策策略。这种数据驱动的决策方式相对于基于规则的方法更为灵活和智能。

挑战与未来展望

数据需求

强化学习模型对于大量的交互数据依赖较大，而在供应链管理中获取真实且丰富的数据可能面临一定的挑战。解决这一问题可能需要结合仿真数据和实际运营数据。

训练时间

训练复杂的强化学习模型可能需要大量的时间和计算资源。在实际应用中，需要权衡训练时间和模型性能，以确保在可接受的时间范围内取得令人满意的结果。

模型解释性

强化学习模型通常被视为"黑盒"，难以解释其决策背后的逻辑。在某些行业中，模型的解释性是一个重要的考量因素，因此需要在解释性和性能之间找到平衡点。

未来，随着研究的深入和技术的发展，我们可以期待强化学习在供应链管理领域的更广泛应用。更先进的算法、更有效的训练方法以及更智能的模型将推动供应链管理迈向新的高度，实现更为智能、敏捷和可持续的运营。

实际案例：供应链智能调度系统

为了更具体地展示强化学习在供应链管理中的应用，我们可以考虑一个实际案例：供应链智能调度系统。该系统的目标是通过优化订单处理和物流调度，降低成本、提高效率。

场景描述

假设我们有一个电子产品供应链，涉及从制造商到分销商再到零售商的多个环节。订单数量和供应链延迟的不确定性使得传统的调度系统难以应对。

强化学习模型

我们可以设计一个强化学习模型，将不同的环节作为状态，并定义订单处理、库存管理、物流调度等操作作为动作。模型的奖励可以考虑成本、交货时间和库存水平等因素。通过与环境的交互，模型将学习在不同情境下做出最优决策的策略。

代码示例

以下是一个简化的示例，演示了一个强化学习调度系统的代码：

ini 复制代码 
# 在这个简化的示例中，我们使用强化学习来优化订单处理和库存管理的决策

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam

# 定义强化学习代理
class SupplyChainAgent:
    def __init__(self, state_size, action_size, learning_rate=0.001, discount_factor=0.9, exploration_prob=0.2):
        self.state_size = state_size
        self.action_size = action_size
        self.learning_rate = learning_rate
        self.discount_factor = discount_factor
        self.exploration_prob = exploration_prob

        self.model = self.build_model()

    def build_model(self):
        model = Sequential()
        model.add(Dense(24, input_dim=self.state_size, activation='relu'))
        model.add(Dense(24, activation='relu'))
        model.add(Dense(self.action_size, activation='linear'))
        model.compile(loss='mse', optimizer=Adam(lr=self.learning_rate))
        return model

    def select_action(self, state):
        if np.random.rand() < self.exploration_prob:
            return np.random.choice(self.action_size)
        else:
            q_values = self.model.predict(state)
            return np.argmax(q_values[0])

    def train(self, state, action, reward, next_state):
        target = self.model.predict(state)
        target[0][action] = reward + self.discount_factor * np.amax(self.model.predict(next_state)[0])
        self.model.fit(state, target, epochs=1, verbose=0)

# 定义供应链环境
class SupplyChainEnvironment:
    def __init__(self, order_processing_cost, inventory_holding_cost, lead_time, demand_distribution):
        self.order_processing_cost = order_processing_cost
        self.inventory_holding_cost = inventory_holding_cost
        self.lead_time = lead_time
        self.demand_distribution = demand_distribution

    def step(self, action):
        # 模拟供应链环境
        demand = np.random.choice(self.demand_distribution)
        lead_time_demand = np.random.choice(self.demand_distribution)

        # 计算成本
        order_cost = self.order_processing_cost * action
        holding_cost = self.inventory_holding_cost * max(0, lead_time_demand - action)

        # 计算奖励
        reward = -order_cost - holding_cost

        return reward

# 初始化代理和环境
state_size = 3  # 状态包括库存水平、订单处理成本、供应链延迟
action_size = 5  # 动作表示订单量
agent = SupplyChainAgent(state_size, action_size)
env = SupplyChainEnvironment(order_processing_cost=5, inventory_holding_cost=1, lead_time=2, demand_distribution=[10, 20, 30])

# 训练代理
num_episodes = 1000
for episode in range(num_episodes):
    state = np.random.rand(1, state_size)  # 初始状态随机生成
    total_reward = 0

    for step in range(50):  # 最大步数，避免无限循环
        action = agent.select_action(state)
        reward = env.step(action)

        # 更新代理
        next_state = np.random.rand(1, state_size)  # 下一个状态随机生成
        agent.train(state, action, reward, next_state)

        total_reward += reward
        state = next_state

    if episode % 100 == 0:
        print(f"Episode {episode}, Total Reward: {total_reward}")

在实际应用中，模型需要更复杂的状态表示、动作空间以及更丰富的数据来训练。这个简化的示例只是为了演示强化学习在供应链环境中的一般应用方法。

这段代码是一个简化的供应链问题的强化学习示例。让我为你解析一下：

  1. 导入库和模块:

    • numpy 用于数值操作。
    • tensorflow 是深度学习框架。
    • Sequential，Dense，和 Adam 是 Keras 中用于构建神经网络的类和优化器。
javascript 复制代码 
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam

  1. 定义强化学习代理类 (SupplyChainAgent) :

    • 代理包含一个神经网络模型，该模型接收状态作为输入，输出动作的 Q 值。
    • select_action 方法用于选择动作，可以根据 Q 值选择最佳动作，或以一定的概率进行探索。
    • train 方法用于训练模型，根据当前状态、动作、奖励和下一个状态来更新 Q 值。
ruby 复制代码 
class SupplyChainAgent:
    def __init__(self, state_size, action_size, learning_rate=0.001, discount_factor=0.9, exploration_prob=0.2):
        # ...

    def build_model(self):
        # ...

    def select_action(self, state):
        # ...

    def train(self, state, action, reward, next_state):
        # ...

  1. 定义供应链环境类 (SupplyChainEnvironment) :

    • 该类模拟了供应链环境，其中 step 方法接收一个动作，模拟了供应链环境中的一步操作，计算成本，并返回奖励。
ruby 复制代码 
class SupplyChainEnvironment:
    def __init__(self, order_processing_cost, inventory_holding_cost, lead_time, demand_distribution):
        # ...

    def step(self, action):
        # ...

  1. 初始化代理和环境:

    • 初始化了代理和环境对象，指定了供应链环境的一些参数，如订单处理成本、库存持有成本、供应链延迟等。
ini 复制代码 
state_size = 3
action_size = 5
agent = SupplyChainAgent(state_size, action_size)
env = SupplyChainEnvironment(order_processing_cost=5, inventory_holding_cost=1, lead_time=2, demand_distribution=[10, 20, 30])

  1. 训练代理:

    • 在一定数量的 episodes 内，代理与环境交互，选择动作，接收奖励，更新模型，以学习在不同状态下选择最优动作的策略。
python 复制代码 
num_episodes = 1000
for episode in range(num_episodes):
    # ...

    for step in range(50):
        # ...
        agent.train(state, action, reward, next_state)

    if episode % 100 == 0:
        print(f"Episode {episode}, Total Reward: {total_reward}")

请注意，这只是一个简化的示例，实际中可能需要更复杂的环境和模型来解决供应链问题。

总结

本文深入探讨了强化学习在供应链管理中的应用，特别关注了使用强化学习优化供应链管理的方法和潜在的优势。我们首先介绍了强化学习的基本概念，然后针对库存管理这一关键领域提供了代码示例，展示了强化学习如何优化决策过程。

在库存管理的案例中，我们采用了Q学习和深度强化学习两种方法，分别展示了简单的强化学习代理和基于深度神经网络的代理。这些方法可以根据不同的业务需求进行调整和扩展，从而更好地适应实际供应链环境。

随后，我们深入探讨了强化学习在供应链管理中的优势，包括适应性、最大化长期利益和数据驱动决策。这些优势使得强化学习成为应对供应链不确定性、优化决策并提高长期竞争力的有力工具。

在挑战与未来展望中，我们指出了一些可能面临的问题，如数据需求、训练时间和模型解释性。解决这些挑战需要继续深入研究和技术创新。

最后，通过一个实际案例展示了供应链智能调度系统的应用，强调了强化学习在实际业务场景中的潜在价值。这个案例提供了一个具体的示例，展示了如何将强化学习集成到供应链管理中，以实现更智能、敏捷和高效的运营。

总的来说，强化学习在供应链管理中的应用为企业提供了一种新颖而有效的方法，有望推动供应链领域的创新和发展。在未来，随着技术的不断演进，我们可以期待看到更多复杂、智能的强化学习模型应用于实际供应链场景，为企业带来更大的业务价值。

相关推荐
Terry Cao 漕河泾18 分钟前
SRT3D: A Sparse Region-Based 3D Object Tracking Approach for the Real World
人工智能·计算机视觉·3d·目标跟踪
多猫家庭23 分钟前
宠物毛发对人体有什么危害？宠物空气净化器小米、希喂、352对比实测
人工智能·宠物
AI完全体27 分钟前
AI小项目4-用Pytorch从头实现Transformer（详细注解）
人工智能·pytorch·深度学习·机器学习·语言模型·transformer·注意力机制
AI知识分享官27 分钟前
智能绘画Midjourney AIGC在设计领域中的应用
人工智能·深度学习·语言模型·chatgpt·aigc·midjourney·llama
程序小旭1 小时前
Objects as Points基于中心点的目标检测方法CenterNet—CVPR2019
人工智能·目标检测·计算机视觉
阿利同学1 小时前
yolov8多任务模型-目标检测+车道线检测+可行驶区域检测-yolo多检测头代码+教程
人工智能·yolo·目标检测·计算机视觉·联系 qq1309399183·yolo多任务检测·多检测头检测
CV-King1 小时前
计算机视觉硬件知识点整理（三）：镜头
图像处理·人工智能·python·opencv·计算机视觉
Alluxio官方1 小时前
Alluxio Enterprise AI on K8s FIO 测试教程
人工智能·机器学习
AI大模型知识分享1 小时前
Prompt最佳实践｜指定输出的长度
人工智能·gpt·机器学习·语言模型·chatgpt·prompt·gpt-3
十有久诚1 小时前
TaskRes: Task Residual for Tuning Vision-Language Models
人工智能·深度学习·提示学习·视觉语言模型
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04苍穹外卖面试总结05yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07软件工程从理论到实践客观题汇总(头歌第一章至第八章)08Coze扣子平台完整体验和实践（附国内和国际版对比）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CCF-CSP认证考试 202406-3 文本分词 100分题解