深度学习在运筹学领域的应用

    import gym
    import numpy as np
    from collections import deque
    import tensorflow as tf
    
    # 定义DQN模型
    class DQNAgent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.memory = deque(maxlen=2000)
        self.gamma = 0.95    # discount rate
        self.epsilon = 1.0   # exploration rate
        self.epsilon_min = 0.01
        self.epsilon_decay = 0.995
        self.learning_rate = 0.001
        self.model = self._build_model()
    
    def _build_model(self):
        # Neural Network model
        model = tf.keras.models.Sequential()
        model.add(tf.keras.layers.Dense(24, input_dim=self.state_size, activation='relu'))
        model.add(tf.keras.layers.Dense(24, activation='relu'))
        model.add(tf.keras.layers.Dense(self.action_size, activation='linear'))
        model.compile(loss='mse', optimizer=tf.keras.optimizers.Adam(lr=self.learning_rate))
        return model
    
    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done))
    
    def act(self, state):
        if np.random.rand() <= self.epsilon:
            return np.random.randint(0, self.action_size)
        act_values = self.model.predict(state)
        return np.argmax(act_values[0])  # returns action
    
    def replay(self, batch_size):
        minibatch = random.sample(self.memory, batch_size)
        for state, action, reward, next_state, done in minibatch:
            target = reward
            if not done:
                target = (reward + self.gamma * np.amax(self.model.predict(next_state)[0]))
            target_f = self.model.predict(state)
            target_f[0][action] = target
            self.model.fit(state, target_f, epochs=1, verbose=0)
        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-12/jRuXB3FimgSQYq0h7eIEGOlrbftk.png)

    import numpy as np
    import tensorflow as tf
    from scipy.optimize import linprog
    
    # 生成随机的线性规划问题
    n = 10 # 变量个数
    m = 5 # 约束个数
    c = np.random.rand(n) # 目标函数系数
    A = np.random.rand(m, n) # 约束矩阵
    b = np.random.rand(m) # 约束右端项
    
    # 定义深度神经网络模型
    model = tf.keras.models.Sequential()
    model.add(tf.keras.layers.Dense(32, input_dim=n, activation='relu'))
    model.add(tf.keras.layers.Dense(32, activation='relu'))
    model.add(tf.keras.layers.Dense(m+1, activation='linear'))
    
    # 训练模型拟合目标函数和约束条件
    X = np.random.rand(1000, n) # 训练样本
    y1 = np.dot(X, c) # 目标函数值
    y2 = np.dot(X, A.T) # 约束条件值
    y = np.concatenate((y1, y2), axis=1)
    model.compile(optimizer='adam', loss='mse')
    model.fit(X, y, epochs=1000, batch_size=32, verbose=0)
    
    # 使用训练好的模型求解优化问题
    def objective(x):
    return model.predict(x[np.newaxis, :])[0][0]
    
    def constraint(x):
    return model.predict(x[np.newaxis, :])[0][1:]
    
    res = linprog(-objective, constraints={'type': 'lez', 'fun': constraint}, bounds=(0, None))
    print(res.x) # 输出最优解
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-12/x7YZznI6BGeCyK10Vod5EgMLWirQ.png)