使用python实现梯度下降算法(详细注释及运行结果)

本例使用的代价函数为 y = ( θ − 2.5 ) 2 − 1 y=(\theta - 2.5)^2-1 y=(θ2.5)21,如果要使用其他代价函数,需要同时修改J(theta)dJ(theta)函数

需要设置不同的学习率可以改变第71行函数传入参数

可以通过修改54行的epsilon来控制停止的时机

结果

学习率 η = 0.1 \eta = 0.1 η=0.1时:

共训练了46次

image-20220130184411795

学习率 η = 0.8 \eta=0.8 η=0.8时:

共训练了22次

image-20220130184359995

代码

# -*- coding:utf-8
"""
作者: Jia
日期: 2022年01月30日
描述: 梯度下降算法的实现
"""
import matplotlib.pyplot as plt
import numpy as np


def J(theta):
    """
    损失函数
    :param theta: 自变量值
    :return: 损失函数的值
    """
    return (theta - 2.5) ** 2 - 1


def dJ(theta):
    """
    损失函数的导数
    :param theta: 自变量值
    :return: 对应点处的导数值
    """
    return 2 * (theta - 2.5)


def plotJ(x, y, theta_history):
    """
    绘制代价函数的图形
    :param x: 横坐标
    :param y: 纵坐标
    :return: None
    """
    plt.plot(np.array(theta_history), J(np.array(theta_history)), color='r', marker='.')
    plt.plot(x, y)
    # 设置坐标轴名称
    plt.xlabel('theta', fontproperties='simHei', fontsize=15)
    plt.xlabel('损失函数', fontproperties='simHei', fontsize=15)
    plt.show()


def gradient_descent(eta):
    """
    梯度下降法求最优点
    :param eta: 学习率
    :return:
        theta: 最优点的取值
        theta_history: 学习过程中theta的取值
    """
    theta = 0.0
    theta_history = [theta]
    epsilon = 1e-8  # 当两次下降的差值小于该值时停止训练

    while True:
        gradient = dJ(theta)  # 求得该点处的导数值
        last_theta = theta
        theta = theta - eta * gradient  # 使用梯度下降计算新的theta
        theta_history.append(theta)  # 保留theta的取值,用于画图像
        if abs(J(theta) - J(last_theta)) < epsilon:
            break

    return theta, theta_history


if __name__ == '__main__':
    plot_x = np.linspace(-1, 6, 141)  # 取从-1到6的141个点
    plot_y = J(plot_x)  # 得到y坐标值

    theta, theta_history = gradient_descent(1.1)  # 在这里可以设置不同的学习率的取值
    plotJ(plot_x, plot_y, theta_history)  # 绘制代价函数图像
    print("共训练了", len(theta_history), "次")
  • 0
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
很抱歉,我只是一个语言模型,无法提供完整的代码实现。不过我可以为您提供一些相关的参考资料和思路,希望对您有所帮助。 首先,A3C算法是一种强化学习算法,用于解决连续动作空间的问题。在柔性车间调度问题,我们可以将每个机器和每个任务视为一个状态,并将每个机器的加工时间和每个任务的处理时间视为可选的动作。目标是最小化总加工时间。 下面是一个简单的A3C实现的代码框架,供您参考: ```python import numpy as np import tensorflow as tf import gym # 定义全局参数 global_step = tf.Variable(0, trainable=False) learning_rate = tf.train.exponential_decay(0.001, global_step, 1000, 0.96, staircase=True) max_episode_length = 100 gamma = 0.99 entropy_factor = 0.01 num_workers = 4 # 定义神经网络结构 class PolicyNetwork(): def __init__(self, state_size, action_size, scope, global_step): self.state_size = state_size self.action_size = action_size self.scope = scope self.global_step = global_step self.optimizer = tf.train.AdamOptimizer(learning_rate) with tf.variable_scope(self.scope): self.inputs = tf.placeholder(tf.float32, [None, self.state_size], name="inputs") self.actions = tf.placeholder(tf.int32, [None], name="actions") self.advantages = tf.placeholder(tf.float32, [None], name="advantages") # 定义神经网络结构 ... self.probs = tf.nn.softmax(self.logits) self.log_probs = tf.log(self.probs) self.entropy = -tf.reduce_sum(self.probs * self.log_probs) # 定义损失函数和梯度 ... # 定义训练操作 ... def predict(self, state, sess): # 使用神经网络预测动作概率 ... def update(self, state, action, advantage, sess): # 计算梯度并更新神经网络 ... # 定义工作进程 class Worker(): def __init__(self, env, policy, global_step, num_episodes): self.env = env self.policy = policy self.global_step = global_step self.num_episodes = num_episodes def train(self, sess): for episode in range(self.num_episodes): state = self.env.reset() episode_reward = 0 episode_history = [] for t in range(max_episode_length): # 选择动作 action_prob = self.policy.predict(state, sess) action = np.random.choice(range(self.policy.action_size), p=action_prob) next_state, reward, done, _ = self.env.step(action) episode_reward += reward episode_history.append([state, action, reward]) state = next_state if done: break # 计算优势值 episode_history = np.array(episode_history) states = episode_history[:, 0] actions = episode_history[:, 1] rewards = episode_history[:, 2] values = self.policy.predict(states, sess) future_rewards = np.zeros_like(rewards) running_add = 0 for t in reversed(range(len(rewards))): running_add = running_add * gamma + rewards[t] future_rewards[t] = running_add advantages = future_rewards - values # 更新神经网络 self.policy.update(states, actions, advantages, sess) sess.close() # 主函数 def main(): env = gym.make("FlexWorkshop-v0") state_size = env.observation_space.shape[0] action_size = env.action_space.n global_policy = PolicyNetwork(state_size, action_size, "global", global_step) workers = [] for i in range(num_workers): env = gym.make("FlexWorkshop-v0") worker_policy = PolicyNetwork(state_size, action_size, "worker_" + str(i), global_step) worker = Worker(env, worker_policy, global_step, 1000) workers.append(worker) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) saver = tf.train.Saver() for episode in range(1000): episode_rewards = [] sess.run(tf.assign(global_step, episode)) # 训练工作进程 for worker in workers: worker.train(sess) # 更新全局网络 ... # 保存模型 if episode % 100 == 0: saver.save(sess, "model.ckpt", global_step=episode) ``` 在这个代码框架,我们首先定义了全局参数和神经网络结构,然后定义了工作进程和主函数。工作进程是独立的,每个进程都有自己的环境和策略网络,它们通过与全局网络的交互来学习并更新策略。主函数负责创建工作进程,启动训练过程,更新全局网络,并保存模型。 需要注意的是,此代码框架仅用于参考,实际代码需要根据具体问题和数据进行修改和优化。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hydrion-Qlz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值