优化_内存优化 - CSDN
  • 程序员的数学-优化理论
  • (1)了解最优化模型。 (2)掌握线性规划的优化求解。 (3)掌握整数规划的优化求解。 (4)了解Matlab的图形化应用。 二、实例演练  1、谈谈你对最优化模型的了解。  最优化模型是数学建模大赛中最常见的...

    一、学习目标

    (1)了解最优化模型。

    (2)掌握线性规划的优化求解。

    (3)掌握整数规划的优化求解。

    (4)了解Matlab的图形化应用。

    二、实例演练

         1、谈谈你对最优化模型的了解。

            最优化模型是数学建模大赛中最常见的问题类型之一。一般说来,凡是寻求最大、最小、最远、最近、最经济、最丰富、最高效、最耗时的目标,都可以划入优化问题的范畴。MATLAB 优化工具箱和全局优化工具箱对多个优化问题提供了完整的解决方案,前者涵盖了线性规划、混合整型线性规划、二次规划、非线性优化、非线性最小二乘的求解器,后者囊括了全局搜索、多初始点、模式搜索、遗传算法等求解算法。

           最优化即在一定的条件下,寻求使目标最小(大)的设计参数或决策。在优化问题中有两个关键对象:目标函数约束条件。哈哈哈,这让笔者想起来高中学到的线性规划,其实,本节谈到的最优化模型跟高中的线性规划还真有点像。不过,高中的线性规划问题约束条件很少,一般是通过作图法来求解。本节的最优化模型约束条件一般比高中的线性规划多很多,并且我们要通过写代码去求解,而不是作图。常规优化问题,其数学表达可以描述为:

    其中x 为长度n的决策变量向量,f(x) 为目标函数,G(x) 为约束函数。

    以上数学表达式看不明白也没关系,因为下面我们会通过两个具体的例子去讲解分析。

    求解目标函数的最小(大)值,一个高效而精确的解决方案不仅取决于约束条件和变量数量,更取决于目标函数和约束函数的特性。明确优化类型是确认优化方案的前提,让我们看一下这些特性如何划分:

    常见的目标函数有:

    线性规划:被广泛的应用于变量之间可线性表示的财务、能源、运营研究等现代管理领域中。

    混合整数线性规划:扩展了线性规划问题,增加了最优解中部分或全部变量必须是整数的约束。例如,如果一个变量代表要认购的股票数量,则只应取整数值。同样,如果一个变量代表发电机的开/关状态,则只应取二进制值(0 或 1)。

    二次规划:目标函数或约束函数为多元二次函数。此优化应用于财务金融中投资组合优化、发电厂发电优化、工程中设计优化等领域。

    最小二乘:分为线性和非线性,通过最小化误差的平方和寻找变量的最优函数匹配。非线性最小二乘优化还可用于曲线拟合。

     

    对 MATLAB 提供的各类优化问题的算法,我们称之为求解器(Solver)。根据其求解目标,被分为四大组:

    • 极小值优化组:找到目标函数出发点 x0 附近的局部极小值

    • 多目标优化组:找到最小化一组函数的最大值或指定的值

    • 方程求解组:找到非线性方程 f(x) = 0 出发点 x0 附近的解

    • 最小二乘法(曲线拟合)组:最小化平方和

    仅优化工具箱就提供了近 20 种求解器,面对如此繁多的选项,用户往往一头雾水。幸好,MATLAB 提供了简单明了的参考工具 —— 优化决策表。可谓一表在手,优化不愁:

    上表中*表示算法由全局工具箱提供。

    我的天呀,你是不是已经被上面的内容吓傻了。看不太懂?没关系。我们现在只需知道有那么一回事即可,不必苦恼。等遇到相应的问题时我们再去结合具体的例子去深入学习和理解。

        2、已知目标函数和约束条件如下,试求解目标函数的最小值。

                                 

           初一看,HPS、PP、EP、P1、I1,……等等,这些是什么东东?别紧张,它们只是变量,把它们当成x,y,z这种常见的变量去看待即可。我数了一下,约束函数中共有19条数学表达式,涉及16个变量。是挺难搞的,用高中的作图法怕是解决不了。别怕,我们有Matlab,通过代码去搞定它。

           好,现在我们开始一步步去求解它。

    a. 首先,根据题目确认这是一个线性规划问题。而线性规划的通用数学表达式和MATLAB标准形式为:

    这个标准形式很重要,上面的A,b,Aeq,beq,lb,ub我们后面要用到。

    b. 对于线性规划的优化求解步骤(也适用于其他优化方案),建议如下:

        1 ) 选择优化求解器

        2 ) 将所有变量合并为一个向量

        3 ) 创建边界约束(lb,ub)

        4 ) 创建线性不等式约束(A,b)

        5 ) 创建线性等式约束(Aeq,beq)

        6 ) 创建目标函数

        7 ) 优化问题求解

        8 ) 结果检验

    上面的求解步骤非常重要,我们的代码整体框架跟求解步骤差不多。

    现在我们按照上面的求解步骤去求解:

    (1)选择优化求解器。

    这道题目是这是一个线性规划问题。求解线性规划问题,我们一般选用linprog。linprog在写代码将要写完才需用到。在第一步我们只需要知道一个线性规划问题,代码按照求解线性规划问题去写即可。

    (2)将所有变量合并为一个向量。

    目标函数和约束条件中共有HPS、PP、EP、P1、I1等16个变量,我们需要将其合并为一个向量。除了合并为一个向量外,我们还将每个变量依次分别赋值1,2,3,4,……16。

    %% 将所有变量合并为一个向量,共16个变量
    variables = {'I1','I2','HE1','HE2','LE1','LE2','C','BF1','BF2','HPS','MPS','LPS','P1','P2','PP','EP'}
    N = length(variables)
    for v = 1:N
        eval([variables{v},'=',num2str(v),';'])
    end

    (3)创建边界约束(lb,ub)

    lb是指low boundary,即最低边界。ub是指up boundary,即最高边界。在这一步中,我们需要把约束条件里的不等式(该不等式只含单个变量,如2500<=P1<=6250,3000<=P2<=9000)找出来,并根据它们的上下边界写代码。

    %% 设置上下限约束(lb<=x<=ub)
    % 设置下限约束,即lb<=x
    lb = zeros(size(variables)); % 1x16的矩阵,每个数都是0
    lb([P1,P2,MPS,LPS]) = [2500,3000,271536,100623];
    % 设置上限约束,即x<=ub
    ub = Inf(size(variables)); % 1想6的矩阵,每个数都是无穷大
    ub([P1,P2,I1,I2,C,LE2])= [6250,9000,192000,244000,62000,142000];

    (4)创建线性不等式约束(A,b)。

    在这一步需要将约束条件里的不等式(该不等式含两个或两个以上变量)找出来,并根据它们的上下边界写代码。

    %% 创建线性不等式约束(A*x<=b)
    A = zeros(3,16); % 3x16的矩阵,每个数均为0,为什么是3x16,因为约束条件有3个不等式
    % 由不等式I1-HE1<=132000得到下面一行代码
    A(1,I1)=1; A(1,HE1)=-1; b(1) = 132000;
    % 由不等式-EP-PP<=12000得到下面一行代码
    A(2,EP)=-1; A(2,PP)=-1; b(2) = -12000;
    % 由不等式-P1-P2-PP<=-24550得到下面一行代码
    A(3,[P1,P2,PP])=[-1,-1,-1];b(3)=-24550;

    (5)创建线性等式约束(Aeq,beq)。

    在这一步需要把约束条件中的等式找出来,并通过移项,让等式的右边为0。

    %% 创建线性等式约束(Aeq*x=beq)
    Aeq=zeros(8,16);beq=zeros(8,1) % 约束条件中共有8个等式
    % 把等式I2=LE2+HE2转化为LE2+HE2-I2=0后,得到下面一行代码
    Aeq(1,[LE2,HE2,I2])=[1,1,-1];
    Aeq(2,[LE1,LE2,BF2,LPS])=[1,1,1,-1];
    Aeq(3,[I1,I2,BF1,HPS])=[1,1,1,-1];
    Aeq(4,[C,MPS,LPS,HPS])=[1,1,1,-1];
    Aeq(5,[LE1,HE1,C,I1])=[1,1,1,-1];
    Aeq(6,[HE1,HE2,BF1,BF2,MPS])=[1,1,1,-1,-1];
    Aeq(7,[HE1,LE1,C,P1,I1])=[1267.8,1251.4,192,3413,-1359.8];
    Aeq(8,[HE2,LE2,P2,I2])=[1267.8,1251.4,3413,-1359.8];

    (6)创建目标函数。

    %% 创建目标函数
    f = zeros(size(variables));
    % 由目标函数0.002614HPS+0.0239PP+0.009825EP
    f([HPS,PP,EP]) = [0.002614,0.0239,0.009825];

    (7) 求解问题

    %% 由linprog实现线性规划问题求解
    options = optimoptions('linprog','Algorithm','dual-simplex');
    % 将前面已经确定的各个参数传入linprog()中
    [x, fval] = linprog(f,A,b,Aeq,beq,lb,ub,options);
    for d=1:N
        fprintf('%12.2f\t%s\n',x(d),variables{d})
    end

    fprintf函数是将求解后每个变量的打印出来。

    求解结果如下:

    下面把完整的源代码贴上:

    clc,clear,close all
    %% 选择优化求解器,线性规划求解可由linprog实现
    
    %% 将所有变量合并为一个向量,共16个变量
    variables = {'I1','I2','HE1','HE2','LE1','LE2','C','BF1','BF2','HPS','MPS','LPS','P1','P2','PP','EP'}
    N = length(variables)
    for v = 1:N
        eval([variables{v},'=',num2str(v),';'])
    end
    
    %% 设置上下限约束(lb<=x<=ub)
    % 设置下限约束,即lb<=x
    lb = zeros(size(variables)); % 1x16的矩阵,每个数都是0
    lb([P1,P2,MPS,LPS]) = [2500,3000,271536,100623];
    % 设置上限约束,即x<=ub
    ub = Inf(size(variables)); % 1想6的矩阵,每个数都是无穷大
    ub([P1,P2,I1,I2,C,LE2])= [6250,9000,192000,244000,62000,142000];
    
    %% 创建线性不等式约束(A*x<=b)
    A = zeros(3,16); % 3x16的矩阵,每个数均为0,为什么是3x16,因为约束条件有3个不等式
    % 由不等式I1-HE1<=132000得到下面一行代码
    A(1,I1)=1; A(1,HE1)=-1; b(1) = 132000;
    % 由不等式-EP-PP<=12000得到下面一行代码
    A(2,EP)=-1; A(2,PP)=-1; b(2) = -12000;
    % 由不等式-P1-P2-PP<=-24550得到下面一行代码
    A(3,[P1,P2,PP])=[-1,-1,-1];b(3)=-24550;
    
    %% 创建线性等式约束(Aeq*x=beq)
    Aeq=zeros(8,16);beq=zeros(8,1) % 约束条件中共有8个等式
    % 把等式I2=LE2+HE2转化为LE2+HE2-I2=0后,得到下面一行代码
    Aeq(1,[LE2,HE2,I2])=[1,1,-1];
    Aeq(2,[LE1,LE2,BF2,LPS])=[1,1,1,-1];
    Aeq(3,[I1,I2,BF1,HPS])=[1,1,1,-1];
    Aeq(4,[C,MPS,LPS,HPS])=[1,1,1,-1];
    Aeq(5,[LE1,HE1,C,I1])=[1,1,1,-1];
    Aeq(6,[HE1,HE2,BF1,BF2,MPS])=[1,1,1,-1,-1];
    Aeq(7,[HE1,LE1,C,P1,I1])=[1267.8,1251.4,192,3413,-1359.8];
    Aeq(8,[HE2,LE2,P2,I2])=[1267.8,1251.4,3413,-1359.8];
    
    %% 创建目标函数
    f = zeros(size(variables));
    % 由目标函数0.002614HPS+0.0239PP+0.009825EP
    f([HPS,PP,EP]) = [0.002614,0.0239,0.009825];
    
    %% 由linprog实现线性规划问题求解
    options = optimoptions('linprog','Algorithm','dual-simplex');
    % 将前面已经确定的各个参数传入linprog()中
    [x, fval] = linprog(f,A,b,Aeq,beq,lb,ub,options);
    for d=1:N
        fprintf('%12.2f\t%s\n',x(d),variables{d})
    end

      3、下面是一个整数规划问题,已知目标函数和约束条件如下,求解目标函数的最大值。

                                          

         求解最大值问题和求解最小值问题本质上是一致的,求解最大值也可以转换为求解最小值。

    例如:本题要求解z=3*x1-2*x2+5*x3的最大值,也就是要求解y=-3*x1+2*x2-5*x3的最小值。求解线性规划最小值问题我们在上面已经学过。本题还有一个比较特殊的问题是,约束条件中的三个变量均为整数,而且是0或1,这也是所谓的0-1规划问题。

    求解整值问题要用到专门的求解器 intlinprog。

    clc,clear,close all
    % 求z=3*x1 - 2*x2 + 5*x3的最大值转化为求y=-3*x1 + 2*x2 - 5*x3的最小值。
    f = [-3;2;-5]; % 创建目标函数
    intcon=[1,2,3];
    A=[1 2 -1; 1 4 1; 1 1 0; 0 4 1]; % 四个不等式中的变量系数
    b=[2;4;3;6]; % 约束条件中不等式右边的常数
    lb=[0,0,0]; % x1,x2,x3=0
    ub=[1,1,1]; % x1,x2,x3=1
    Aeq=[0,0,0];
    beq=0;
    x=intlinprog(f,intcon,A,b,Aeq,beq,lb,ub)

    我想提一下intcon=[1,2,3]这句代码是怎么回事。

    下面我举一个简单的例子来说明intcon的用法。

    X=[x1,x2,x3,x4,x5,x6],其中x2, x3, x6只能取整数
    intcon = [2,3,6]
    如果所有变量都只能取整数,则:intcon = [1,2,3,4,5,6]; 比较方便的写法是:intcon = 1:6
    如果只有x4取整数,则:intcon = 4;就是约束整形变量

    在本题中,除了x1,x2,x3=0或1外,没有其它的等式了。故Aeq=[0,0,0];beq=0;

     4、图形化应用

    在数学建模竞赛中,我们一般通过代码来进行求解问题,图形化应用可以用来检验结果是否正确。

    MATLAB 在数据分析领域如此受欢迎,除了其提供丰富的内置算法集,还有各类友好的应用界面。在优化工具箱中,也有这么一个强大的工具—— Optimization App,可以在 MATLAB Apps 窗口或者运行 optmitool 命令打开。它是一个交互式的图形化应用工具,无需手写代码,直接在图形界面中设置各类求解器、配置目标函数、约束条件,即可运行优化算法并使中间结果和最终结果可视化。

    在 Optimization App 中,只需点击菜单栏中的 File > Generate Code,即可将 App 中的各项设置自动生成 MATLAB 代码,用户可实现算法的复用和二次开发。

    展开全文
  • 必装软件 yum -y install gcc glibc gcc-c++ make ... yum -y install setuptool ntsysv system-config-securitylevel-tui NetworkMana...

    最小化安装centos后必要的优化

    1、配置网络及更改计算机名

    改计算机名

    hostnamectl set-hostname pokes

    配置网络

    vi /etc/sysconfig/network-scripts/ifcfg-ens33

    网络配置文件内容编辑如下(有注释的是必须改的):

    TYPE="Ethernet"
    BOOTPROTO="static"    #静态
    DEFROUTE="yes"
    PEERDNS="yes"
    PEERROUTES="yes"
    IPV4_FAILURE_FATAL="no"
    IPV6INIT="yes"
    IPV6_AUTOCONF="yes"
    IPV6_DEFROUTE="yes"
    IPV6_PEERDNS="yes"
    IPV6_PEERROUTES="yes"
    IPV6_FAILURE_FATAL="no"
    NAME="eno16777736"
    UUID="0e6ca219-0d2e-4000-8f17-bf7424e46595"
    DEVICE="eno16777736"
    ONBOOT="yes"        #开机开启网卡
    IPADDR=192.168.255.101
    GATEWAY=192.168.255.2
    NETMASK=255.255.255.0
    DNS=114.114.114.114

    2、更改系统源

     

    首先备份源 /ect/yum.repos.d/CentOS-Base.repo,在安装之前我们先必须安装wget

    yum -y install wget yum-utils epel-release
    mv  /etc/yum.repos.d/CentOS-Base.repo  /etc/yum.repos.d/CentOS-Base.repo.bak

    替换为阿里源

    wget -O  /etc/yum.repos.d/CentOS-Base.repo  http://mirrors.aliyun.com/repo/Centos-7.repo
    yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

    清楚缓存、生成新缓存

    yum clean all && yum makecache

    3、更新系统

    yum -y upgrade

    升级所有包,不改变软件设置和系统设置,系统版本升级,内核不改变 (不变内核和设置,升级包和系统版本)

    不建议使用update 

    yum -y update

    升级所有包,改变软件设置和系统设置,系统版本内核都升级

    详细请看这里:https://blog.csdn.net/weixin_34415923/article/details/92598179

    4、安装常用的软件

    yum -y install gcc
    yum -y install glibc 
    yum -y install gcc-c++ 
    yum -y install make 
    yum -y install cmake
    yum -y install net-tools
    yum -y install screen
    yum -y install vim
    yum -y install lrzsz
    yum -y install tree
    yum -y install dos2unix
    yum -y install lsof
    yum -y install tcpdump
    yum -y install bash-completion
    yum -y install wget
    yum -y install ntp
    yum -y install setuptool
    yum -y install psmisc
    yum -y install openssl
    yum -y install openssl-devel
    yum -y install bind-utils
    yum -y install traceroute

    一键安装

    yum -y install gcc glibc gcc-c++ make cmake net-tools screen vim lrzsz tree dos2unix lsof tcpdump bash-completion wget ntp setuptool psmisc openssl openssl-devel bind-utils traceroute
    • gcc  glibc  gcc-c++  make cmake  编译器,编译安装的时候会用到
    • net-tools           #Linux内核中配置网络功能的工具
    • screen              #用于命令行终端切换
    • vim                   #编辑器
    • lrzsz                 #拖动上传,sz下载
    • tree                  #树形目录
    • dos2unix          #Windows格式文件转换为Unix、Linux格式的实用命令
    • lsof                  #列出当前系统打开文件的工具
    • tcpdump          #抓包工具
    • bash-completion     #自动补全功能增强
    • wget                 #文件下载
    • ntp                    #同步网络事件
    • psmisc              #帮助管理/proc目录的程序
    • openssl    openssl-devel         #web安全通信的基石,没有openssl,可以说我们的信息都是在裸奔

    图形化配置网络/服务/防火墙

    • setuptool        #安装setup命令工具

    • ntsysv            #安装setup工具配套的系统服务组件

    • system-config-securitylevel-tui     #安装setup工具配套的防火墙配置组件

    • NetworkManager-tui                    #安装setup工具配套的网络配置组件

    • authconfig-gtk                              #安装setup工具配套的验证配置组件

    • system-config-keyboard              #安装setup工具配套的键盘配置组件

    • bind-utils                                      #解决没有nslookup命令

    yum -y install setuptool
    yum -y install ntsysv
    yum -y install system-config-securitylevel-tui
    yum -y install NetworkManager-tui authconfig-gtk
    yum -y install system-config-keyboard
    yum -y install bind-utils

    一键安装

    yum -y install setuptool ntsysvsystem-config-securitylevel-tui networkManager-tui authconfig-gtk system-config-keyboard bind-utils

    5、关闭防火墙(测试环境)

    systemctl disable firewalld
    systemctl stop firewalld
    sed -i 's/^ *SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config

    6、添加普通用户并进行sudo授权管理

    7、默认打开vim增加行号

    vim 要默认打开的时候显示行号,这样就可以不用每次编辑的时候在手动在命令模式下:set number 来显示行号。

    具体做法是: 创建一个 .vimrc的配置文件。

    在启动vim时,当前用户根目录下的.vimrc文件会被自动读取,该文件可以包含一些设置甚至脚本,所以,一般情况下把.vimrc文件创建在当前用户的根目录下比较方便,即创建的命令为:

    $vi ~/.vimrc

    往文件里面添加内容: set number , 保存退出。

    8、更改ssh默认端口

    9、禁止root远程登录 切记给系统添加普通用户,给su到root的权限

    10、root用户密码输入错误三次,锁定账户一段时间

    11、设置时区并同步时间

    12、历史命令显示操作时间

    13、SSH超时时间

    14、禁止定时任务向发送邮件

    sed -i 's/^MAILTO=root/MAILTO=""/' /etc/crontab

     

    不断更新

     

     

     

    展开全文
  • 为什么需要优化算法优化算法可以加快收敛速度(未加入优化的神经网络训练时间比加入优化后时间更短),甚至得到一个更好更小的损失函数值。优化算法能帮你快速高效地训练模型。有哪些优化算法 Mini-Batch 梯度下降 ...

    为什么需要优化算法

    优化算法可以加快收敛速度(未加入优化的神经网络训练时间比加入优化后时间更短),甚至得到一个更好更小的损失函数值。优化算法能帮你快速高效地训练模型。

    有哪些优化算法

    • Mini-Batch 梯度下降
    • Momentum 动量梯度下降法
    • RMSprop
    • Adam 提升算法

    其中Adam提升算法是Momentum和RMSprop两种相结合的算法,接下来我们会依次介绍这四种算法。

    Mini-Batch 梯度下降

    算法介绍

    训练集被分割为小的子训练集,这些子训练集被称为mini-batch。假设每个子集只有1000个训练数据,那么先取前1000个开始训练(训练方法与梯度下降完全相同,不同的只是对训练集进行了分割),再取接下来的1000个继续训练,依次类推,直到训练完所有的训练数据。以mini-batch为64为例,过程如下图所示:这里写图片描述

    特别的,当每个mini-batch的大小为1时,得到一种新算法,叫做随机梯度下降,此时每次只取一个样本进行训练,效率过于低下,会失去向量化带来的加速。当mini-batch的大小为训练数据本身时,得到batch梯度下降,也就是我们普通的梯度下降算法(此时损失函数关于迭代次数的图像上,应该是一个持续下降的曲线,如果有上升的情况,那就是学习速率过大)

    三种不同mini-batch代码对比

    以下代码来自吴恩达coursera《deep learning》课后编程作业
    - (Batch) Gradient Descent:

    X = data_input
    Y = labels
    parameters = initialize_parameters(layers_dims)
    for i in range(0, num_iterations):
        # Forward propagation
        a, caches = forward_propagation(X, parameters)
        # Compute cost.
        cost = compute_cost(a, Y)
        # Backward propagation.
        grads = backward_propagation(a, caches, parameters)
        # Update parameters.
        parameters = update_parameters(parameters, grads)
    
    • Stochastic Gradient Descent:
    X = data_input
    Y = labels
    parameters = initialize_parameters(layers_dims)
    for i in range(0, num_iterations):
        for j in range(0, m):
            # Forward propagation
            a, caches = forward_propagation(X[:,j], parameters)
            # Compute cost
            cost = compute_cost(a, Y[:,j])
            # Backward propagation
            grads = backward_propagation(a, caches, parameters)
            # Update parameters.
            parameters = update_parameters(parameters, grads)
    • Mini-batch Gradient Descent:
    X = data_input
    Y = labels
    parameters = initialize_parameters(layers_dims)
    for i in range(0, num_iterations):
         for minibatch in minibatches:
            # Select a minibatch
            (minibatch_X, minibatch_Y) = minibatch
    
            # Forward propagation
            a3, caches = forward_propagation(minibatch_X, parameters)
            # Compute cost
            cost = compute_cost(a3, minibatch_Y)
    
            # Backward propagation
            grads = backward_propagation(minibatch_X, minibatch_Y, caches)
            # Update parameters.
            parameters = update_parameters_with_gd(parameters, grads, learning_rate)

    所以,我们的目标是找一个大小适中的mini-batch。

    mini-batch选取数据集代码实现

    # GRADED FUNCTION: random_mini_batches
    
    def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):
        """
        Creates a list of random minibatches from (X, Y)
    
        Arguments:
        X -- input data, of shape (input size, number of examples)
        Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (1, number of examples)
        mini_batch_size -- size of the mini-batches, integer
    
        Returns:
        mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)
        """
    
        np.random.seed(seed)            # To make your "random" minibatches the same as ours
        m = X.shape[1]                  # number of training examples
        mini_batches = []
    
        # Step 1: Shuffle (X, Y)
        permutation = list(np.random.permutation(m))
        shuffled_X = X[:, permutation]
        shuffled_Y = Y[:, permutation].reshape((1,m))
    
        # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.
        num_complete_minibatches = math.floor(m/mini_batch_size) # number of mini batches of size mini_batch_size in your partitionning
        for k in range(0, num_complete_minibatches):
            mini_batch_X = shuffled_X[:, mini_batch_size*k : mini_batch_size*(k+1)]
            mini_batch_Y = shuffled_Y[:, mini_batch_size*k : mini_batch_size*(k+1)]
            mini_batch = (mini_batch_X, mini_batch_Y)
            mini_batches.append(mini_batch)
    
        # Handling the end case (last mini-batch < mini_batch_size)
        if m % mini_batch_size != 0:
            mini_batch_X = shuffled_X[:, mini_batch_size*num_complete_minibatches : m]
            mini_batch_Y = shuffled_Y[:, mini_batch_size*num_complete_minibatches : m]
            mini_batch = (mini_batch_X, mini_batch_Y)
            mini_batches.append(mini_batch)
    
        return mini_batches

    Momentum 动量梯度下降法

    算法介绍

    由于Mini-batch梯度下降使用数据子集进行参数更新,所以更新的方向跟普通的batch梯度下降有些不同,而是有一些变化(这里是指,不同的数据子集在进行梯度下降时,可能使损失函数值上升,但总趋势是下降的),因此小批量梯度下降的路径将会“震荡”到收敛。使用动量可以减少震荡。这些“变化“形象化表示如下:
    这里写图片描述

    动量梯度下降的公式如下:

    {vdW[l]=βvdW[l]+(1β)dW[l]W[l]=W[l]αvdW[l]
    {vdb[l]=βvdb[l]+(1β)db[l]b[l]=b[l]αvdb[l]

    其中 β 是动量,一般设置为0.9, α 是学习速率。该公式蕴含这一种思想——指数加权平均。这里我不过多地从数学角度解释为什么这样,一个我个人认为易于理解的解释是,这种表达从图形化的角度来看,是把过去的梯度下降考虑在内来平滑当下的梯度变化,从而减小垂直方向上的震荡,同时保持水平方向上的下降速度。
    这里写图片描述

    代码实现

    def update_parameters_with_momentum(parameters, grads, v, beta, learning_rate):
        """
        Update parameters using Momentum
    
        Arguments:
        parameters -- python dictionary containing your parameters:
                        parameters['W' + str(l)] = Wl
                        parameters['b' + str(l)] = bl
        grads -- python dictionary containing your gradients for each parameters:
                        grads['dW' + str(l)] = dWl
                        grads['db' + str(l)] = dbl
        v -- python dictionary containing the current velocity:
                        v['dW' + str(l)] = ...
                        v['db' + str(l)] = ...
        beta -- the momentum hyperparameter, scalar
        learning_rate -- the learning rate, scalar
    
        Returns:
        parameters -- python dictionary containing your updated parameters 
        v -- python dictionary containing your updated velocities
        """
    
        L = len(parameters) // 2 # number of layers in the neural networks
    
        # Momentum update for each parameter
        for l in range(L):
            # compute velocities
            v["dW" + str(l+1)] = beta*v["dW" + str(l+1)]+(1-beta)*grads["dW" + str(l+1)]
            v["db" + str(l+1)] =beta*v["db" + str(l+1)]+(1-beta)*grads["db" + str(l+1)]
            # update parameters
            parameters["W" + str(l+1)] = parameters["W" + str(l+1)]-learning_rate*v["dW" + str(l+1)]
            parameters["b" + str(l+1)] = parameters["b" + str(l+1)]-learning_rate*v["db" + str(l+1)]
    
        return parameters, v

    RMSprop算法

    算法介绍

    与前一个算法的目的相同,我们想减少纵轴上的震荡,同时增大横纵上的收敛速度。我们推出跟前一个类似的公式:

    sdW[l]=β2sdW[l]+(1β2)(JW[l])2W[l]=W[l]αdWsdw[l]
    一个不太严谨的解释是,由于纵轴的震荡较大,即dw较大,s就会较大,当s被除后,使w变化较小。而横轴上下降较慢,同理推出运算后,使变化增大。

    Adam算法

    该算法是前两种算法的结合版本。公式如下:

    vdW[l]=β1vdW[l]+(1β1)JW[l]vcorrecteddW[l]=vdW[l]1(β1)tsdW[l]=β2sdW[l]+(1β2)(JW[l])2scorrecteddW[l]=sdW[l]1(β1)tW[l]=W[l]αvcorrecteddW[l]scorrecteddW[l]+ε

    - L is the number of layers
    - β1 and β2 are hyperparameters that control the two exponentially weighted averages. 一般来说β1=0.9 β2 =0.999我们的目标不是来调整这两个参数的。
    - α is the learning rate
    - ε is a very small number to avoid dividing by zero 一般设为108

    Adam更新参数的代码

    def update_parameters_with_adam(parameters, grads, v, s, t, learning_rate = 0.01,
                                    beta1 = 0.9, beta2 = 0.999,  epsilon = 1e-8):
        """
        Update parameters using Adam
    
        Arguments:
        parameters -- python dictionary containing your parameters:
                        parameters['W' + str(l)] = Wl
                        parameters['b' + str(l)] = bl
        grads -- python dictionary containing your gradients for each parameters:
                        grads['dW' + str(l)] = dWl
                        grads['db' + str(l)] = dbl
        v -- Adam variable, moving average of the first gradient, python dictionary
        s -- Adam variable, moving average of the squared gradient, python dictionary
        learning_rate -- the learning rate, scalar.
        beta1 -- Exponential decay hyperparameter for the first moment estimates 
        beta2 -- Exponential decay hyperparameter for the second moment estimates 
        epsilon -- hyperparameter preventing division by zero in Adam updates
    
        Returns:
        parameters -- python dictionary containing your updated parameters 
        v -- Adam variable, moving average of the first gradient, python dictionary
        s -- Adam variable, moving average of the squared gradient, python dictionary
        """
    
        L = len(parameters) // 2                 # number of layers in the neural networks
        v_corrected = {}                         # Initializing first moment estimate, python dictionary
        s_corrected = {}                         # Initializing second moment estimate, python dictionary
    
        # Perform Adam update on all parameters
        for l in range(L):
            # Moving average of the gradients. Inputs: "v, grads, beta1". Output: "v".
            v["dW" + str(l+1)] = beta1*v["dW" + str(l+1)]+(1-beta1)*grads["dW" + str(l+1)]
            v["db" + str(l+1)] = beta1*v["db" + str(l+1)]+(1-beta1)*grads["db" + str(l+1)]
    
            # Compute bias-corrected first moment estimate. Inputs: "v, beta1, t". Output: "v_corrected".
            ### START CODE HERE ### (approx. 2 lines)
            v_corrected["dW" + str(l+1)] =  v["dW" + str(l+1)]/(1-np.power(beta1,t))
            v_corrected["db" + str(l+1)] = v["db" + str(l+1)]/(1-np.power(beta1,t))
    
            # Moving average of the squared gradients. Inputs: "s, grads, beta2". Output: "s".
            s["dW" + str(l+1)] =  beta2*s["dW" + str(l+1)]+(1-beta2)*grads["dW" + str(l+1)]*grads["dW" + str(l+1)]
            s["db" + str(l+1)] =beta2*s["db" + str(l+1)]+(1-beta2)*grads["db" + str(l+1)]*grads["db" + str(l+1)]
    
            # Compute bias-corrected second raw moment estimate. Inputs: "s, beta2, t". Output: "s_corrected".
            s_corrected["dW" + str(l+1)] = s["dW" + str(l+1)]/(1-np.power(beta2,t))
            s_corrected["db" + str(l+1)] = s["db" + str(l+1)]/(1-np.power(beta2,t))
            # Update parameters. Inputs: "parameters, learning_rate, v_corrected, s_corrected, epsilon". Output: "parameters".
            parameters["W" + str(l+1)] = parameters["W"+str(l+1)]-learning_rate*v_corrected["dW"+str(l+1)]/(np.sqrt(s_corrected["dW"+str(l+1)])+epsilon)
            parameters["b" + str(l+1)] = parameters["b"+str(l+1)]-learning_rate*v_corrected["db"+str(l+1)]/(np.sqrt(s_corrected["db"+str(l+1)])+epsilon)
    
        return parameters, v, s

    总结

    动量下降通常是有帮助的,但是如果使用了小的学习速率和简单的数据集,它的影响微乎其微。Adma的内存需求较低,工作性能也很好。实际中我们常用这种作为调优方式。

    展开全文
  • Windows10必做的优化

    2018-07-26 17:04:03
    (2017年9月28日更新)Win10在经过几个大版本迭代更新后,目前(创意者更新)已非常稳定,几乎没有需要优化的地方,请普通用户直接使用即可。 工具/原料 Windows10操作系统 电脑 关闭家庭组 (2018年5月...

     有些人升级win10后发现,win10并没想象中顺畅,反而很占资源。其实,只需做一些小调整就能大幅提高win10效率。

    (2017年9月28日更新)Win10在经过几个大版本迭代更新后,目前(创意者更新)已非常稳定,几乎没有需要优化的地方,请普通用户直接使用即可。

    工具/原料

    • Windows10操作系统

    • 电脑

    关闭家庭组

    (2018年5月10日更新)目前的Win10最新版(版本号1803,四月更新)中家庭组功能已被砍掉。 

    (1)右键点击“此电脑”,选择“管理”,进入“计算机管理”窗口。

    (2)在左侧的菜单选择“服务”,并在右侧找到“HomeGroup Listener”和“HomeGroup Provider”两个服务。

    (3)右键点击它,选择“属性”,并在新打开的窗口中把启动类型改为“禁用”。

    (5)这样,就关闭了“家庭组”功能。win8时代就有的家庭组功能会不断读写硬盘,造成硬盘占用高,这个问题在win10中依然存在。关闭这个功能会使硬盘占用大幅降低,不再出现动不动就占用100%的情况。(可在任务管理器中查看)

    卸载无用应用

    打开开始菜单里的“设置”应用,依次进入“系统”→“应用和功能”,可以卸掉一些您用不到的系统自带应用。

    设置里还有许多可以调整的地方,您可以自行探索。

    关闭优化驱动器

    (1)双击“此电脑”打开,右键点击任意磁盘,选择“属性”。

    (2)在上方的标签选择“工具”,然后点击“优化”。

    (3)在下方“已计划的优化”处点“更改设置”,然后取消计划。

    (4)win10的“优化驱动器”即win7时代的磁盘碎片整理,每两三个月做一次即可,每周计划运行实属磨损硬盘。

    关闭IPV6服务

    如果您的网络运营商不分配IPV6地址,可以将其关闭。

    (1)右键点击“此电脑”,选择“管理”,进入“计算机管理”窗口。在左侧的菜单选择“服务”,并在右侧找到“IPHelper”。右键点击它,选择“属性”,并在新打开的窗口中把启动类型改为“禁用”。方法基本同第一部分。

    关闭用户账户控制(UAC)(不推荐)

    用户账户控制是从Vista时代就产生的功能,用来拦截可能危害系统的操作,但一定程度上会骚扰用户,所以可以选择关掉它。

    (1)打开控制面板,选择“用户账户”。

    (2)在用户账户中,选择“更改用户账户控制设置”,在打开的新窗口中把滑块拉到底并确定。

    使用优化软件

    一些软件,例如XX安全卫士,XX电脑管家,XX魔方等有启动项和服务优化功能,可根据情况使用。

    【 哈哈,问题解决了,领个支付宝红包 。支付宝首页搜索“519449706”领大额现金红包】

     

     

    展开全文
  • 前端优化是复杂的,针对方方面面的资源都有不同的方式。那么,前端优化的目的是什么 ?  1. 从用户角度而言,优化能够让页面加载得更快、对用户的操作响应得更及时,能够给用户提供更为友好的体验。  2. 从服务商...
  • 页面优化

    2014-05-07 10:52:25
    前端优化是复杂的,针对方方面面的资源都有不同的方式。那么,前端优化的目的是什么   1. 从用户角度而言,优化能够让页面加载得更快、对用户的操作响应得更及时,能够给用户提供更为友好的体验。 2. 从...
  • 优化理论(1)

    2019-03-26 20:27:53
    优化本质上是一个优化问题,所以我们先来看优化问题是什么。 优化问题有三个最重要的因素:目标函数、优化变量、优化约束。一个简单的优化问题可以描述如下: 其中x为优化变量,而F(x)为优化函数。此问题称为...
  • 优化理论与方法

    2019-04-23 12:28:47
    优化问题 :eg:,其中x在控制问题中被称为为控制决策变量;在数学优化中叫做决策量。无论是最优控制还是数学优化(数学规划)都是优化问题,即都是这样的形式。 1. 优化的两个基本问题 确定一个优化的必要或/和...
  • 优化的定义 1.1 凸优化 ...1.1 凸优化优化问题目前在机器学习,数据挖掘等领域应用非常广泛,因为机器学习简单来说,主要做的就是优化问题,先初始化一下权重参数,然后利用优化方法来优化这个
  • 我们每个人都会在我们的生活或者工作中遇到各种各样的最优化问题,比如每个企业和个人都要考虑的一个问题“在一定成本下,如何使利润最大化”等。最优化方法是一种数学方法,它是研究在给定约束之下如何寻求某些因素...
  • sql优化的几种方法

    2017-08-17 20:59:55
    在sql查询中为了提高查询效率,我们常常会采取一些措施对查询语句进行sql优化,下面总结的一些方法,有需要的可以参考参考。 1.对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上...
  • SEO优化网站教程6

    2019-08-23 09:04:49
    SEO优化网站教程之6个经典软件操作顺序6个经典软件操作顺序网站关键词优化到百度首页其主要关键在于网站内容关联建设,掌握【网站标题-网站首页长尾关键词建设-文章标题-文章内容】这三者紧密和高度关联性。...
  • sql优化的几种方式

    2019-11-11 09:15:50
    一、为什么要对SQL进行优化 我们开发项目上线初期,由于业务数据量相对较少,一些SQL的执行效率对程序运行效率的影响不太明显,而开发和运维人员也无法判断SQL对程序的运行效率有多大,故很少针对SQL进行专门的优化...
  • 数据库优化 - SQL优化

    2019-12-13 10:33:07
    以实际SQL入手,带你一步一步走上SQL优化之路!
  • 网上关于SQL优化的教程很多,但是比较杂乱。近日有空整理了一下,写出来跟大家分享一下,其中有错误和不足的地方,还请大家纠正补充。 这篇文章我花费了大量的时间查找资料、修改、排版,希望大家阅读之后,感觉好的...
  • Win10必做的性能优化

    2019-05-17 10:14:16
    Windows10系统目前慢慢成为主流的操作系统,win7目前已经不再提供技术支持,到2020年正式退役。...由于win10系统功能变多,系统也变得臃肿,下面就给大家讲讲Windows10必做的优化。 1.关闭家...
  • SEO优化网站教程4

    2019-08-23 09:06:35
    SEO优化网站教程之文章插入长尾词内链技巧文章插入长尾词内链技巧下面我们举例说明一:下面我们举例说明二:有需要更全面的SEO优化网站软件工具及软件操作文档可以联系博主,会有更详细的教程,系统的帮助您的网站...
  • 做科研时,曾花了段时间学习凸优化,后来发现ML中其应用也非常普遍,想来今后可能还会接触,干脆做个系统的总结,方便以后查询。 博文内容主要参考Boyd(Stanford)的Convex Optimization,配套的slides,以及部分...
  • 粒子群优化算法(PSO)

    2019-07-22 09:51:31
    粒子群优化算法(Partical Swarm Optimization PSO),粒子群中的每一个粒子都代表一个问题的可能解,通过粒子个体的简单行为,群体内的信息交互实现问题求解的智能性。由于PSO操作简单、收敛速度快,...
1 2 3 4 5 ... 20
收藏数 2,342,425
精华内容 936,970
关键字:

优化