精华内容
下载资源
问答
  • 机器学习】L1与L2权重正则化 L1正则化用于LR称为Lasso Rrgression; L2用于LR称为Rindge回归; 两者均可防止过拟合,但是L1正则化倾向于产生稀疏的权重(即部分权重为0,部分权重不为0); 原因: 梯度后可以...

    前言

    深度学习优化中的损失函数L\mathcal{L}通常由两部分组成,经验损失Lemp\mathcal{L_{emp}}与正则损失Ω(f)\mathcal{\Omega(f)},可以描述如下: L=Lemp+λΩ(f)\mathcal{L}=\mathcal{L_{emp}}+\lambda\mathcal{\Omega(f)}经验损失尽可能地拟合数据集,从数据集中挖掘规则,然而由于数据集采样的随机性与有限性,经验分布无法准确描述数据生成分布,容易导致过拟合问题的发生。正则化损失编码了我们对模型、问题的先验知识,体现了我们对模型的归纳偏好,致力于提高模型的泛化能力。综合两种损失,即可以挖掘数据提供的信息避免过拟合,又可以充分利用人们的先验知识提升泛化性能。

    正则损失通常可以分为两类:一般性的正则损失(如L1,L2正则化、奥卡姆剃刀原则、最大熵原则),领域相关的正则损失。本文重点描述L1、L2正则损失。

    概念

    L1正则损失:Ω(f)=θθ\mathcal{\Omega(f)}=\sum\limits_{\theta}|\theta|
    L2正则损失:Ω(f)=θθ22\mathcal{\Omega(f)}=\sum\limits_{\theta}||\theta||_2^2

    特点

    L1归纳偏好:学习到的模型权重稀疏
    L2归纳偏好:学习到的模型权重平滑

    理解

    参数的极大似然估计

    参数估计的方式有矩估计、极大似然估计、贝叶斯估计。机器学习常用的为后两者。极大似然估计认为参数是确定的值,并把再当前参数配置下样本的发生概率作为当前参数配置的似然,然后最大化参数的似然,即argmaxθP(Xθ)\arg\max\limits_{\theta} P(X|\theta),然后基于学到的参数来预测。贝叶斯估计认为参数是服从先验分布的随机变量,给定当前观测XX下,可以获得对参数的进一步认知,得到参数的后验分布P(θX)P(\theta|X),并基于参数的后验分布做预测。由于贝叶斯估计考虑对参数的先验知识,所以通常情况下贝叶斯估计要优于极大似然估计,但是贝叶斯决策是基于参数的后验分布来决策的,所以计算量较大。通过综合两者的优点可以得到参数的最大后验概率估计,即argmaxθP(θX)\arg\max\limits_{\theta} P(\theta|X)。进一步,
    argmaxθP(θX)=argmaxθP(Xθ)P(θ)P(X)=argmaxθP(Xθ)P(θ)=argmaxθlogP(Xθ)+logP(θ)\begin{aligned} &\arg\max\limits_{\theta} P(\theta|X)\\ =&\arg\max\limits_{\theta}\frac{P(X|\theta)P(\theta)}{P(X)}\\ =&\arg\max\limits_{\theta}P(X|\theta)P(\theta)\\ =&arg\max\limits_{\theta} \log P(X|\theta)+\log P(\theta) \end{aligned}
    由此可知,最大后验概率估计相当于考虑了参数先验分布的极大似然估计。

    θLaplace(0λ)\theta\thicksim Laplace(0,\lambda)时,logP(θ)=1λθ+C\log P(\theta)=-\frac{1}{\lambda}|\theta|+C,取负后并约去常数项后可以得到1λθ\frac{1}{\lambda}|\theta|,由于每个参数独立同分布,故可以得到1λθθ\frac{1}{\lambda}\sum\limits_{\theta}|\theta|,即L1正则损失。而Laplace分布是尖峰分布,随着与0距离的增加,概率密度指数衰减,虽然避免了极端大或者小的权重,但概率密度主要集中在0附近,使模型倾向于得到稀疏权重,使得部分特征或者神经单元不起作用(使用L1损失时需要强先验:特征包含部分无关特征,需要通过稀疏来进行特征选择降低无关特征的作用,不然还是推荐L2损失)。

    θN(0,δ2)\theta\thicksim N(0, \delta^2)时, logP(θ)=1δ2θ2+C\log P(\theta)=-\frac{1}{\delta^2}\theta^2+C,取负并约去常数项得到1δ2θ2\frac{1}{\delta^2}\theta^2,由于每个参数独立同分布,故可以得到1δ2θθ2\frac{1}{\delta^2}\sum\limits_{\theta}\theta^2,即L2正则损失。相比于Laplace分布,正态分布在主要集中在[-3,3]区域,避免了极端大或小的权重,变化比较平缓,所以很容易得到平滑的权重

    注:Laplace分布: f(x)=12λexμλf(x)=\frac{1}{2\lambda}e^{-\frac{|x-\mu|}{\lambda}}, 从下图可以看出laplace分布相当于两个背靠背的指数分布
    在这里插入图片描述

    lagrange约束优化

    argminLemps.t.Ω(f)<T\arg\min \mathcal{L_{emp}} \quad s.t. \quad\Omega(f)<T对应的lagrange函数为:Lemp+λΩ(f)+C(λ0)\mathcal{L_{emp}}+\lambda\mathcal{\Omega(f)}+C(\lambda\ge0),假设最优解取得的地方λ=λ,w=w\lambda=\lambda^*, w=w^*,则从Lemp+λΩ(f)\mathcal{L_{emp}}+\lambda^*\mathcal{\Omega(f)}中求得的最优解ww也为ww^*,也就是说加正则的损失函数求得的最优解相当于argminLemps.t.Ω(f)<T\arg\min \mathcal{L_{emp}} \quad s.t. \quad\Omega(f)<T的最优解。

    梯度更新角度

    L1的梯度:L1θ=λ|\frac{\partial L1}{\partial \theta}|=\lambda为常值, 当权重接近0时,仍保持固定的步长,可以接近0,从而得到稀疏权重。另一方面,在权重0的左右,梯度相差为2λ2\lambda,极有有可能两边梯度异号,导致参数0处为驻点(即SGD优化的目标),从而导致稀疏权重

    L2的梯度:L2θ=λθ|\frac{\partial L2}{\partial \theta}|=\lambda \theta为与权重有关的变量,当权重接近0时,L2带来的梯度更新越来越小,很难真正为0,所 以不容易产生稀疏权重。

    二阶近似角度

    可视化角度(均方经验损失为例)

    以均方经验经验损失为例,在高维参数空间下它的等值线为超椭球。考虑二维参数空间,图中绿色的的轮廓线为均方经验损失的等值线,越往外,值越大。L1损失的等值线为左图中的正方形,L2损失的等值线为有图中的圆。固定经验损失,即给定一条绿色的线,计算曲线上任意一点的L1或者L2损失,可以发现给定一条绿色的线,具有最小的L1损失的解倾向于在坐标轴上(即具有稀疏权重),具有最小的L2损失的解倾向于离原点近,但是没有在坐标轴上的倾向(即非稀疏权重)

    另一种理解方式:固定正则损失,即给定一条黑色的线,考虑只有一个交点的情况:L2只有两个圆在坐标轴方向相切时,才可能取得部分权重为0的解。L1正则化在每个坐标轴方向每个方向有90度的方向相切,从这个角度看,L1正则化得到稀疏解的可能是L2得到稀疏解的可能的无穷倍。
    在这里插入图片描述
    图片来源:https://img-blog.csdnimg.cn/20190717204327273.png

    扩展1–>L1L2L_{1}L_{2}正则化与线性回归

    L1正则化应用于线性回归模型时被称为Lasso回归,常用于保险业,L1正则化表达了希望模型学到稀疏解的倾向,这有利于数据分析师从大量特征中找出对目标因素影响最大的因素,忽略次要因素(L1正则化也是融合式的特征选择方法)。

    L2正则化应用于线性回归模型时被称为Ridge回归,常用于特征之间存在多重共线性的情况,L2正则化表达了希望模型学到小的权重的倾向,当存在多重共线性时,存在无穷解,不容易收敛或者容易得到权重很大解,造成模型对小的扰动不稳定,这也与传统模型的局部不变性先验不一致,加上正则化后,模型最优解唯一,此时有利于收敛。

    一些其它想法:机器学习中常用的归纳偏置都是相通的,奥卡姆剃刀、最小描述长度、局部不变性。L1正则化具有这三者的特性,L2正则化也具有这三者的特性(L2的最小描述长度可以这样理解:参数空间缩小,描述参数的编码长度可以减小)。

    扩展2–>LxL_{x}正则化

    可视化:画出LxL_{x}损失的轮廓线来,如下图所示,随着阶数的升高,轮廓线由十字变为正方形,并且高阶损失的轮廓线包裹着低阶损失的轮廓线。
    在这里插入图片描述
    另一种理解方式,对xx的小数部分根据Taylor展开进行二阶近似(在x=1x=1展开)得到θxi1+λθ\theta^{x-i}\sim1+\lambda \theta, LxL_{x}正则化可以看作Li+λLi+1i=floor(x)L_i+ \lambda L_{i+1}, i=floor(x)的组合。所以LxL_{x}的轮廓线应该位于LiL_{i}Li+1L_{i+1}的轮廓线之间。
    图片来源:https://blog.csdn.net/eric41050808/article/details/24365765

    参考博客

    https://blog.csdn.net/m0_38045485/article/details/82147817

    展开全文
  • data=loadWeight('ex3weights.mat') #载入已经好的权重。 theta1=data['Theta1'] theta2=data['Theta2'] theta1=np.transpose(theta1) #两个权重都需要进行转置才可以运算 theta2=np.transpose(theta2) ...

    整个项目的github:https://github.com/RobinLuoNanjing/MachineLearning_Ng_Python

    里面可以下载进行代码实现的数据集

     

     

    题目介绍:

    In the previous part of this exercise, you implemented multi-class logistic regression to recognize handwritten digits. However, logistic regression cannot form more complex hypotheses as it is only a linear classifier.

    In this part of the exercise, you will implement a neural network to recognize handwritten digits using the same training set as before. The neural network will be able to represent complex models that form non-linear hypotheses. For this week, you will be using parameters from a neural network that we have already trained. Your goal is to implement the feedforward propagation algorithm to use our weights for prediction. In next week’s ex- ercise, you will write the backpropagation algorithm for learning the neural network parameters.

     

    翻译:

    在之前的练习中,你实现了用多类逻辑回归去识别手写的数字。但是逻辑回归不能形成更复杂的假设。因为它仅仅是一个线性分类器。

    在这节的练习里,你将会实现用一个神经网络来进行手写数字识别,数据集将会使用和上一节一样的数据。神经网络能够呈现更为复杂的非线性假设的模型。这一周,你们将会使用我们利用神经网络已经训练好的权重。你的目标就是实现前向传播算法进行预测。下周,你需要自己写一个反向传播算法来用神经网络进行学习。

     

    题目解析:

    就是把之前的利用逻辑回归算法里求出的theta,换成他们用神经网络求出的theta,然后进行一次预测。值得注意的是,已经训练好的theta有两组,一个是theta1,一个是theta2。

     

    代码详细解释:

    大部分代码基本上和上一节作业没有变化。

    首先就是删掉了oneVsAll()函数,当然也顺便删掉了costFunction()和gradient()函数。我们不需要求theta,因为theta已经给出了。

     

    1.然后直接看主函数。注意!!!!!!!!!!!!!!这里载入的是ex3data1.mat文件。也就是吴恩达作业中的数据,跟我上一节导入的数据不一样。上一节导入的数据是别人修改过的。区别是:ex3data1.mat文件中,0对应的y值是10!而别人修改过的0对应的值是0。

    区别可大了。ex3weights.mat权重是根据0的y值为10训练的。如果你还采用上一节作业我用的数据,预测准确率大概减少百分之十。

    def logisticRegression_oneVsAll():
        data=loadMatFile('ex3data1.mat')    #1.导入文件。在.mat文件中存放的是两个矩阵,X是图片矩阵(5000x400),每一行都是一个数字图片的矩阵
        X=data['X']
        y=data['y']
    
        m=len(X)
    
        #我们先选100个数字看看。
        rand_indices=[np.random.randint(0,m) for x in range(100)]   #2.显示100个数字:这一步是利用列表表达式选取100个随机的数字。
        show_data(X[rand_indices, :])  # 显示100个数字
    
        X=np.hstack((np.ones((len(y),1)),X))     #先将X中补上一列1。
        # X = np.insert(X, 0, values=np.ones(X.shape[0]), axis=1)
    
        data=loadWeight('ex3weights.mat')      #载入已经求好的权重。
        theta1=data['Theta1']
        theta2=data['Theta2']
    
        theta1=np.transpose(theta1)            #两个权重都需要进行转置才可以运算
        theta2=np.transpose(theta2)
    
    
        theta1=np.insert(theta1,0,1,axis=1)    #这里需要注意下,theta1必须添加一个bias偏置
        predict(theta1,theta2,X,y)     #4.调用predict函数。

     

    2.直接看predict函数。这个函数也是改动比较大。体现了神经网络的分层。X是输入层的数据,X*theta1,并且进行激励函数sigmod的运算,求出的结果就是第二层的数据layer2,也就是a(2)层,然后我们利用a(2)层的数据求出第三层的数据z2,z2进行sigmoid运算求出hx,也就是结果。

    #预测函数
    def predict(theta1,theta2,X,y):
        z=np.dot(X,theta1)     #此时是5000x26
        layer2=sigmoid(z)      #将theta代入到假设函数中去
    
        z2=np.dot(layer2,theta2)   #此时是5000x10
        hx=sigmoid(z2)
    
        m=X.shape[0]
    
        '''
        返回h中每一行最大值所在的列号
        - np.max(h, axis=1)返回h中每一行的最大值(是某个数字的最大概率)
        - 最后where找到的最大概率所在的列号(列号即是对应的数字)
        '''
        p=np.where(hx[0,:]==np.max(hx,axis=1)[0])           #我们需要知道每一行中的最大值,因为这个最大值对应的列数就是我们预测的数字。
        for i in range(1,m):                                #打个比方,第一行数据对应的实际值是0,那么如果预测准确,这一行中的最大值应该是在第0列。
            temp=np.where(hx[i,:]==np.max(hx,axis=1)[i])
            p=np.vstack((p,temp))                           #我们将每一行中的最大值对应的列都添加到p数组中,此时p数组就是存放的每个数字的预测值。
    
        p=p+1             #这里需要将p加1,因为在这个数据集中,0对应的y值是10。所以会导致hx发生偏移。什么意思呢?我们是利用已经求好的theta1和theta2进行计算。求出的
                        #结果hx实际上是按照[1,2,3,4,5,6,7,8,9,0]排列的。而他们所对应的索引是[0,1,2,3,4,5,6,7,8,9]。也就是说我们通过循环求出的索引实际上是偏小的。得+1
    
        print('在当前数据集上,训练的准确度为%f%%'%np.mean(np.float64(p==y)*100))   #我们将预测值p与实际值y,进行比较。如果相同,则为True,不同则为False,通过np.float计算,True为1,Flase为0.
        return p

     

    实验结果:

    这个结果应该是过拟合的。。。

    在当前数据集上,训练的准确度为97.520000%

     

    全部代码:

    import numpy as np
    import matplotlib
    from matplotlib import pyplot as plt
    import scipy.io as spio
    from scipy import optimize
    
    
    np.set_printoptions(suppress=True, threshold=np.nan)    #去除科学计数法,不然看起来太难受
    matplotlib.rcParams['font.family']='Arial Unicode MS' #mac环境下防止中文乱码
    
    
    '''
    1.导入文件loadMatFile(),注意,跟之前不同,这次导入的文件是.mat文件
    2.利用show_data()函数,我们先显示100个数字看看。
    3.直接调用predict函数,并且代入通过神经网络运算求好的theta1和theta2
    '''
    
    
    
    def logisticRegression_oneVsAll():
        data=loadMatFile('ex3data1.mat')    #1.导入文件。在.mat文件中存放的是两个矩阵,X是图片矩阵(5000x400),每一行都是一个数字图片的矩阵
        X=data['X']
        y=data['y']
    
        m=len(X)
    
        #我们先选100个数字看看。
        rand_indices=[np.random.randint(0,m) for x in range(100)]   #2.显示100个数字:这一步是利用列表表达式选取100个随机的数字。
        show_data(X[rand_indices, :])  # 显示100个数字
    
        X=np.hstack((np.ones((len(y),1)),X))     #先将X中补上一列1。
        # X = np.insert(X, 0, values=np.ones(X.shape[0]), axis=1)
    
        data=loadWeight('ex3weights.mat')      #载入已经求好的权重。
        theta1=data['Theta1']
        theta2=data['Theta2']
    
        theta1=np.transpose(theta1)            #两个权重都需要进行转置才可以运算
        theta2=np.transpose(theta2)
    
    
        theta1=np.insert(theta1,0,1,axis=1)    #这里需要注意下,theta1必须添加一个bias偏置
    
    
        #这段代码可以不用看,这是我参考别人的代码
        # a1=X                      #5000x401
        # z2=a1@theta1    #5000x26
        #
        # a2=sigmoid(z2)            #5000x26
        # z3=a2@theta2              #5000x10
        #
        # a3=sigmoid(z3)
        #
        # y_pred = np.argmax(a3, axis=1)+1
        #
        # y=y.flatten()      #这里一定要把y转变为1维数组。因为y_pred就是一维数组
        #
        # accuracy = np.mean(y_pred == y)
        # print('accuracy = {0}%'.format(accuracy * 100))
    
    
    
        predict(theta1,theta2,X,y)     #4.调用predict函数。
    
    
    
    
    #导入mat文件
    def loadMatFile(path):
        return spio.loadmat(path)       #这里我们需要借助scipy.io的loadmat方法来导入.mat文件
    
    
    #导入weight
    def loadWeight(path):
        return spio.loadmat(path)
    
    
    
    
    # 显示随机的100个数字
    '''
    显示100个数(若是一个一个绘制将会非常慢,可以将要画的数字整理好,放到一个矩阵中,显示这个矩阵即可)
        - 初始化一个二维数组
        - 将每行的数据调整成图像的矩阵,放进二维数组
        - 显示即可
    '''
    def show_data(imgs):
        pad=1      #因为我们显示的是100张图片矩阵的集合,所以每张图片我们可以设置一个分割线,对图片进行划分。pad指的是分割线宽度。
        show_imgs=-np.ones((pad+10*(20+pad),pad+10*(20+pad)))    #初始化一个211x211的矩阵,因为100张图片都是20x20,加上分割线,总共的大小就是211x211。
                                                                #这里需要了解下,如果初始化的矩阵值为-1,则分割线的颜色会是黑色。
    
        row=0    #因为我们要显示100个数字,所以我们需要从图片数组的第0行遍历到第99行,这个row是用来控制遍历的行数
    
        for i in range(10):     #双层循环,100张图片放进去。
            for j in range(10):
                show_imgs[pad+i*(20+pad):pad+i*(20+pad)+20,pad+j*(20+pad):pad+j*(20+pad)+20]=(     #这段代码比较复杂。等号左边是从show_imgs这个大矩阵中给图片挑选位置。需要注意图片与图片之间都需要留位置给分割线
                    imgs[row,:].reshape(20,20,order='F'))      #因为imgs中的每个数字是一行400个像素数据,我们需要将其改造为20x20的矩阵。order=F,是指列优先对原数组进行reshape。因为python默认的是以行优先,但是matlab是列优先。如果不加这个的话,所有的数字都是横着显示的
                row+=1
    
        plt.imshow(show_imgs,cmap='gray')  # 显示灰度图像,plt.imshow()函数负责对图像进行处理,并显示其格式,但是不能显示。其后跟着plt.show()才能显示出来。
        plt.axis('off')  #把显示的轴去掉
        plt.show()
    
    
    
    #Sigmoid函数
    def sigmoid(z):
        hx=np.ones((len(z),1))    #初始化一列数组,里面用于存放经过S函数变换后得值。
        hx=1.0/(1.0+np.exp(-z))
    
        return hx
    
    
    
    #预测函数
    def predict(theta1,theta2,X,y):
        z=np.dot(X,theta1)     #此时是5000x26
        layer2=sigmoid(z)      #将theta代入到假设函数中去
    
        z2=np.dot(layer2,theta2)   #此时是5000x10
        hx=sigmoid(z2)
    
        m=X.shape[0]
    
        '''
        返回h中每一行最大值所在的列号
        - np.max(h, axis=1)返回h中每一行的最大值(是某个数字的最大概率)
        - 最后where找到的最大概率所在的列号(列号即是对应的数字)
        '''
        p=np.where(hx[0,:]==np.max(hx,axis=1)[0])           #我们需要知道每一行中的最大值,因为这个最大值对应的列数就是我们预测的数字。
        for i in range(1,m):                                #打个比方,第一行数据对应的实际值是0,那么如果预测准确,这一行中的最大值应该是在第0列。
            temp=np.where(hx[i,:]==np.max(hx,axis=1)[i])
            p=np.vstack((p,temp))                           #我们将每一行中的最大值对应的列都添加到p数组中,此时p数组就是存放的每个数字的预测值。
    
        p=p+1             #这里需要将p加1,因为在这个数据集中,0对应的y值是10。所以会导致hx发生偏移。什么意思呢?我们是利用已经求好的theta1和theta2进行计算。求出的
                        #结果hx实际上是按照[1,2,3,4,5,6,7,8,9,0]排列的。而他们所对应的索引是[0,1,2,3,4,5,6,7,8,9]。也就是说我们通过循环求出的索引实际上是偏小的。得+1
    
        print('在当前数据集上,训练的准确度为%f%%'%np.mean(np.float64(p==y)*100))   #我们将预测值p与实际值y,进行比较。如果相同,则为True,不同则为False,通过np.float计算,True为1,Flase为0.
        return p
    
    
    
    #调用 logisticRegression_oneVsAll函数
    logisticRegression_oneVsAll()

     

     

     

     

     

    展开全文
  • bestWieghts 是 岭回归求得的权重,为什么在数据还原中要除以方差? 【岭回归的标准化数据方式是(x -x均值)/方差】 ``` print ("with constant term: ",-1*sum(multiply(meanX,unReg)) + mean(yMat)) ``` ...
  • 一般游戏的战力公式,是一个线性回归方程:a*x+b*y+c*z+… =p其中,p是...如果两个角色,战斗力相同,而属性可以不同,那么,属性价值相当于各属性的权重,并且属性价值有一个内在关系:x/s+y/s+z/s+… = 1s表示总属...

    一般游戏的战力公式,是一个线性回归方程:

    a*x+b*y+c*z+… =p

     

    其中,p是战斗力,[a,b,c…]是属性,[x,y,z…]是属性价值。

    属性一般包括:最大生命值,攻击力,防御力,闪避,暴击,命中等等。

     

    如果确定了属性价值,那么战斗力就确定了。

     

    如果两个角色,战斗力相同,而属性可以不同,那么,属性价值相当于各属性的权重,并且属性价值有一个内在关系:

    x/s+y/s+z/s+… = 1

    s表示总属性价值。

    x/s表示属性价值因子,总属性价值只和是1.

     

    求取了价值因子,就可以求得权重,也就是属性价值。

     

    很多游戏的属性价值是直觉得出的,这里提供一个机器学习方法

     

     

    检验战斗力的方式,最简单的凭据是,实时战斗。

    如果两个单位在实时战斗的情况下,如果战斗结果势均力敌,表示两个单位战力相当。

    当然,一般影响战斗结果的因素很多,并不仅仅只有战力公式涉及到的属性。例如:单位移动速度,转向速度,AI程度等等。又或者受暴击率,闪避率等影响,一场战斗如果人品爆发次次暴击,也会影响战斗结果。又或者对于有操作的游戏,玩家的操作技巧,也影响战斗结果。

    所以,为了屏蔽这些影响,战斗的时候有先决条件:1.非战斗力公式相关的属性相同;2.暴击率和闪避率一般多次判定之后趋于稳定,影响较小不考虑;3.玩家无法操作。

     

    所以,可以用实时战斗的结果,来评估战斗力。

     

    这里提供一个神经网络模型来进行学习。

    可以看到线性方程,只用一个单层的前馈神经网络可以模拟出来。

     

    输入层是N个神经元,对应N个属性,神经元的输出的权重,就是属性价值因子。而且,属性价值因子只和等于1,恰好满足神经网络的内在形式。

     

    输出层是正则化的战斗力。乘以一个系数就是想要的总战斗力。系数可以随意。

     

     

    属性值 = 属性价值因子*总战斗力

     

    1.首先随机N个神经网络模型,模型的价值因子,是随机的,总和为1.

    这样就得到N个神经网络模型。

     

    2.然后求得属性值,得到N个单位的属性。

     

    3.让这N个单位随机1v1匹配,进行战斗。

     

    胜利的一方,表示这个单位战力比失败一方大,但不能表示这个比最终战斗力大。

     

    如何求得最终权重?

     

    未完待续。。。

     

     

    以下是求取线性伤害公式的算法,战斗力公式使用线性(仅演示作用)

    import numpy as np
    import random
    import math
    import matplotlib.pyplot as plt
    
    #假设战斗单位包含三个属性
    # atk           攻击力
    # def           防御力
    # true_dmg      真实伤害
    #假设伤害公式为:
    # dmg = (player1.atk-0.5*player2.def)+player1.atk_plus
    #这个公式可以直接看出伤害公式的权重比为 atk : def : atk_plus = 1 : 0.5 : 2 = 2 : 1 : 4
    #也就是战力公式为:power = 2*atk+1*def+4*atk_plus
    #我们让两个玩家互相攻击,来训练。最后比较权重。
    
    #需要训练的权重.
    #初始(1,10)之间随机值
    #我们需要利用梯度下降算法,使这些权重比为 2:1:4
    weights = np.random.uniform(1,10,3)
     
    #用伤害计算公式来计算两个玩家的伤害 
    def damage(player1,player2):
    	#攻击减防御
    	dmg = player1[0] - 0.5*player2[1]
    	#第三项为额外输出
    	dmg += 2.0*player1[2]
    	return dmg
    
    #数组求和
    def sum(v):
    	temp_v = 0
    	for i in v:
    		temp_v += i
    	return temp_v
    	
     
    #将权重值变为因子(总和为1)
    def get_weight_factor(p):
    	sum_p = sum(p)
    	return [ p[i]/sum_p for i in range(len(p)) ]
     
    #已知单位的战斗力,以及战力公式的因子的情况下,计算玩家的三项属性值
    #factor 玩家的 三项属性 的权重因子
    #w 战力公式的权重因子
    #power 总战力值
    def get_propertys(factor,w, power):
    	temp_v = []
    	for i in range(len(factor)):
    		temp_v.append(power * factor[i]/w[i])
    	return temp_v
     
     
    #计算两个单位伤害值的方差
    def error(p1,p2):
    	return (damage(p1,p2) - damage(p2,p1))**2
     
    #梯度下降算法
    def gradient_descent(player1_weights_factor,player2_weights_factor):
    	#计算偏导数的间隔
    	delta = 0.001
    	#学习速度
    	rate = 0.001
    
    	#两个单位的战力值相同,依据当前的战力公式的因子,求出两个单位的属性值
    	player1 = get_propertys(player1_weights_factor,weights,power)
    	player2 = get_propertys(player2_weights_factor,weights,power)
    
    	out_param = []
    	for i in range(len(weights)):
    		new_weights = [ x for x in weights]
    		#偏置
    		new_weights[i] += delta
    		#返回新的玩家属性
    		d_p1 = get_propertys(player1_weights_factor,new_weights,power)
    		#计算新的玩家属性,与玩家2的属性的方差的变化
    		d = (error(d_p1,player2)-error(player1,player2))/delta
    		#梯度下降,得到新的权重
    		out_param.append(weights[i] - rate*d)
    	return out_param
     
    #总战力
    power = 100
     
    #打印初始值
    print(weights)
     
    errorData = []
    
    #训练100000次
    for i in range(100000):
     
    	#随机生成两个战斗单位的属性权重因子,他们的属性的比例值是随机的
    	player1_weights_factor = get_weight_factor(np.random.uniform(5,30,3))
    	player2_weights_factor = get_weight_factor(np.random.uniform(5,30,3))
    
    	#梯度下降,生成新的权重
    	weights =  gradient_descent(player1_weights_factor,player2_weights_factor)
    	#每1000次训练,打印结果
    	if i%1000 == 0:
    		p1 = get_propertys(player1_weights_factor,weights,power)
    		p2 = get_propertys(player2_weights_factor,weights,power)
    		errorNum = error(p1,p2)
    		errorData.append(errorNum)
    		#print('p1 {} p2 {}'.format(p1,p2))
    		print('weights = {} error = {:6f}'.format(weights, errorNum))
     
     
     #图形输入值
    input_values = [x*1000 for x in range(len(errorData))]
    #图形输出值
    squares = errorData
    
    #plot根据列表绘制出有意义的图形,linewidth是图形线宽,可省略
    plt.plot(input_values,squares,linewidth=1)
    #设置图标标题
    plt.title("Training",fontsize = 24)
    #设置坐标轴标签
    plt.xlabel("Training Times",fontsize = 14)
    plt.ylabel("error value",fontsize = 14)
    #设置刻度标记的大小
    plt.tick_params(axis='both',labelsize = 14)
    #打开matplotlib查看器,并显示绘制图形
    plt.show()

    输出结果:

     

    总结:

    驯良10000次之后,误差基本稳定下来。

    战力公式的权重比值为:5.13 : 2.56 : 10.28

    约等于伤害计算式的属性价值:2:1:4

    以下是tensorflow实现的算法

    import tensorflow as tf
    import matplotlib.pyplot as plt
    import numpy as np
    
    # 模型,有三个变量 a,b,c
    # 模型输入为玩家属性
    # 模型输出为玩家战斗力
    weights = []
    weights.append( tf.Variable(np.random.uniform(5,10),name='a'))
    weights.append( tf.Variable(np.random.uniform(5,10),name='b'))
    weights.append( tf.Variable(np.random.uniform(5,10),name='c'))
    
    
    # 假设战斗单位包含三个属性
    # atk           攻击力
    # def           防御力
    # true_dmg      真实伤害
    # 假设伤害公式为:
    # dmg = (player1.atk-0.5*player2.def)+player1.atk_plus
    # 战力公式:
    # power = a*atk+b*def+c*true_dmg
    # 则公式权重:2:1:4
    # 训练完成的模型参数对比看是不是这个,如果是则表示正确
    def damage(player1,player2):
    	dmg = player1[0]-0.5*player2[1]
    	dmg += 2.0*player1[2]
    	return dmg
    
    #玩家的总战力
    power = 100
    
    # 随机生成玩家的数据,用来训练
    # 玩家的总战力是100,但三个属性值不一样
    def create_player(weights):
    	#随机玩家三个属性的战力分配比例
    	player_factor = np.random.uniform(5,30,3)
    	player_factor /= np.sum(player_factor)
    
    	#各属性的战力除以战力公式的权重,得到玩家的属性
    	player = []
    	for i in range(len(weights)):
    		player.append(power*player_factor[i]/weights[i])
    
    	return player
    
    
    #定义损失函数
    def loss(p1,p2):
    	error = damage(p1,p2)-damage(p2,p1)
    	return tf.square(error)+0.01*tf.reduce_sum(tf.square(weights))	#加上L2正则化项
    
    
    #训练
    optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)
    
    errorData = []
    
    with tf.GradientTape(persistent=True) as trap:
    	for i in range(5000):
    		player1 = create_player(weights)
    		player2 = create_player(weights)
    		
    		loss_value = loss(player1,player2)
    		grads = trap.gradient(loss_value,weights)
    		optimizer.apply_gradients(zip(grads, weights))
    		result = []
    		
    		result.append(weights[0].numpy())
    		result.append(weights[1].numpy())
    		result.append(weights[2].numpy())
    
    		print("Loss at step {:03d}:weights = {} error =  {:.3f}".format(i,result, loss_value))
    		errorData.append(loss( player1, player2))
    
    #图形输入值
    input_values = [x for x in range(len(errorData))]
    #图形输出值
    squares = errorData
     
    #plot根据列表绘制出有意义的图形,linewidth是图形线宽,可省略
    plt.plot(input_values,squares,linewidth=1)
    #设置图标标题
    plt.title("Training",fontsize = 24)
    #设置坐标轴标签
    plt.xlabel("Training Times",fontsize = 14)
    plt.ylabel("error value",fontsize = 14)
    #设置刻度标记的大小
    plt.tick_params(axis='both',labelsize = 14)
    #打开matplotlib查看器,并显示绘制图形
    plt.show()
    

     

    展开全文
  • 机器学习——总结篇

    2020-05-22 10:40:24
    机器学习的弊端显而易见,如要提取繁杂的特征,对于多特征要进行筛选和特征权重准确率最大化(这中间海涉及到数据降维和特征选择)。中途也搞过一段时间深度学习,深度学习的好处就是只要样本足够大,就能得到...

    搞机器学习断断续续的约有一年半的时间了,摸索着学习,真是痛苦,也走了不少冤枉路,因为针对课题一个人考虑的不够全面。有一些小伙伴关注了我, 估计也都是新人,希望大家少走冤枉路。
    机器学习的弊端显而易见,如要提取繁杂的特征,对于多特征要进行筛选和求特征权重以求准确率最大化(这中间海涉及到数据降维和特征选择)。中途也搞过一段时间深度学习,深度学习的好处就是只要样本足够大,就能得到你想要的结果,并且避免了传统机器学习繁琐的过程。个人觉得入手的话不如直接深度学习,毕竟机器学习和深度学习对于新人难度差不多。
    如果想从机器学习入手的话,推荐炼石成金的培训课,网上有资源。里面有具体的案例,还有你们最喜欢的代码…
    在这里插入图片描述
    在这里插入图片描述
    链接:https://pan.baidu.com/s/1TCAvRvM0lHFAkmafEbGNrA
    提取码:yy8s
    这个是资源,供新人学习。个人认为,如果不打算把机器学习部署到嵌入式中的话,花几个月时间消化掉它就行了。如果把它部署到嵌入式中去做具体的工程项目,还是值得花时间去学习的。深度学习以后是趋势,每年几个顶级的国际图形图像处理会议,中国占的比重越来越高,高水平论文量也在提升如CVPR等。
    接下来的工作是将图像处理部署到嵌入式中,就是DSP AM5728。应用在具体的工程环境中,如无人驾驶、安检、农产品自动分类(色选机)等。这个难度要比图像处理大得多(无论是机器学习还是深度学习),但也是未来发展的必然趋势,算法不部署到硬件上的话,他的应用性将大大降低。看过几个大佬做的交流项目,惊叹厉害!!!
    在这里插入图片描述
    在这里插入图片描述
    也有人去用神经棒或者一些高配的GPU,但在工程中是不合理的,只有在高校或者研发岗位给你用。毕竟他们不具备低功耗,多端口、多控制、成本低等优势。有这方面兴趣的小伙伴一起交流,将图像处理部署到嵌入式中。

    展开全文
  • 机器学习思维里,可以表示为一个每个数字的权重的回归问题。闲来无事、加之刚学完coursesa上的andrew ng的课程,尝试用线性回归解决一下这个问题。 线性回归 模型表示 特征提取:对于0-9,数它在等式左侧...
  • 机器学习之数学基础

    2020-09-08 19:21:00
    1、机器学习的分类 2、得分函数 如图,经过一系列的计算,最后得到的概率值就叫得分函数。这里的w为权重,而怎么得到权重是我们算法的核心目标。得分函数就是对于给定的一个输入,通过计算,得到这个输入属于每种...
  • 机器学习复习模拟题

    万次阅读 2020-02-21 13:04:53
    更新权重 w 时,使用的是矩阵逆还是梯度下降 C. 使用常数项 答案:A 解析:选择合适的多项式阶数非常重要。如果阶数过大,模型就会更加复杂,容易发生过拟合;如果阶数较小,模型就会过于简单,容易发生欠拟合。...
  • 机器学习1

    千次阅读 2016-04-05 21:34:44
    这里面所说的再讨论就是另一种最小化代价函数J的方法,不过这次不是迭代更新然后最小化了,而是直接出θ\theta的解了 所谓局部加权的意思就是,对于一个输入,侧重考虑输入点附近的样本(可以看到那个权重的...
  • 机器学习 回归

    2019-12-22 00:09:32
    w的值使用平方误差 解得 即为“普通最小二乘法”。 用普通最小二乘法可能出现欠拟合的情况,故采用局部加权线性回归 常使用高斯和来赋予权重 如果参数过多,就无法使用线性回归,所以需要缩减。引入了岭回归...
  • 机器学习算法详解

    2018-04-12 15:21:14
    机器学习算法详解▪ 一、线性回归 ◦ 1、代价函数 ◦ 2、梯度下降算法 ◦ 3、均值归一化 ◦ 4、最终运行结果 ◦ 5、使用scikit-learn库中的线性模型实现 ▪ 二、逻辑回归 ◦ 1、代价函数 ◦ 2、梯度 ◦ 3、正则化 ◦...
  • 机器学习理论测试

    万次阅读 2020-09-28 16:06:10
    更新权重 w 时,使用的是矩阵逆还是梯度下降 C. 使用常数项 答案:A 解析:选择合适的多项式阶数非常重要。如果阶数过大,模型就会更加复杂,容易发生过拟合;如果阶数较小,模型就会过于简单,容易发生欠拟合...
  • 接着优化价值函数权重,然后测试验证。这整套的流程是机器学习必经环节。 今天要学习的话题是逻辑回归,逻辑回归也是一种有监督学习方法(supervised machine learning)。 逻辑回归一般用来做预测,也可以...
  • 目前在用机器学习算法解决一个多分类问题,手动提的特征,20多维。有两个类别总是被错误分类成对方,尝试了随机森林、KNN、决策树、XGBoost都是一样的效果。输出特征重要程度feature_importances&...
  • 1.用validation出其中最好的一个作为我们最终的模型。 2.利用所有的模型进行平均投票。 3.非均匀投票。 4.不同条件下给与不同的投票权重。 第一张图像的详细解释。 仅靠一个模型选择可能效果不如众多模型一起的...
  • 从这节算是开始进入“正规”的机器学习了吧,之所以“正规”因为它开始要建立价值函数(cost function),接着优化价值函数权重,然后测试验证。这整套的流程是机器学习必经环节。今天要学习的话题是逻辑回归,...
  • 机器学习线性回归

    2019-03-30 21:15:57
    线性回归 线性回归通过最小化误差的平方和寻找数据的最佳函数匹配。利用最小二乘法可以简便地求得未知的数据,并使得这些求得的数据与实际数据之间误差的平方和为...:w0,w1,w2,w3,即权重向量w 代价函数:J(w)=...
  • 最优化算法在机器学习中是一种求解最合适的权重参数的算法,梯度下降算法就是其中的一种。 概念 梯度下降算法是一个最优化的算法,它是沿梯度下降的方向求解极小值。 前提条件 目标函数 使用梯度下降算法的第一个...
  • 机器学习算法-感知机

    2021-01-31 13:59:07
    机器学习算法-感知机 感知机是线性分类模型,属于判别模型,感知机旨在出将训练数据进行线性划分的分离超平面。感知机模型: f(x)=sign(w⋅x+b)f(x)=sign(w \cdot x+b )f(x)=sign(w⋅x+b) x∈Rnx \in \mathcal{R}^...
  • Python与机器学习总结

    2018-09-13 21:16:03
    思路:建立预测值与真实值之间的误差方程,而所有数据的误差值服从独立同分布的高斯分布,为了使预测值更接近真实值,即当权重为多少时,使偏置最小,关于权重的似然函数,进而对数似然函数的极大值,最后得出...
  • 机器学习_感知机

    2020-08-05 20:29:53
    感知机是二分类的线性分类模型,输入为特征向量,输出位类别(1,-1). 感知机目的是能够讲输入的线性数据进行划分的超平面.对误分类样本损失函数,使其最小...=0,更新权重 更新方法 (4) 转2知道没有误分类点 ...
  • 1. 前言前面我们介绍了使用机器学习的方法进行因子合成,但是这种方法的适用性仍需斟酌使用。例如机器可能会给某个因子过高的权重,为组合带来风险暴露。本文从因子权重优化出发,基于Python Cvxpy库提供了因子权重...
  • 从这节算是开始进入“正规”的机器学习了吧,之所以“正规”因为它开始要建立价值函数(cost function),接着优化价值函数权重,然后测试验证。这整套的流程是机器学习必经环节。今天要学习的话题是逻辑回归,...
  • 机器学习笔试知识点

    2019-10-09 08:55:36
    更新权重 w 时,使用的是矩阵逆还是梯度下降 C. 使用常数项 答案:A 解析:选择合适的多项式阶数非常重要。如果阶数过大,模型就会更加复杂,容易发生过拟合;如果阶数较小,模型就会过于简单,容易发生欠拟合...
  • 机器学习实战书中没有具体推理权重向量θ更新的过程,仅仅是下面三行代码(1)A=x.θ;(2)E=sigmoid(A)-y;(3)θ:=θ-α.x'.E,x'表示矩阵x的转置。 为什么这样更新???Logistic回归总结作者...
  • 机器学习逻辑回归:原理推导

    千次阅读 2017-11-18 07:56:35
    前言到现在为止,我们通过大约1周的时间初步对机器学习是怎么一回事算是有一些基本的理解了,从最基本的线性回归入手,讨论了如何在拿到一堆数据时,先进行数据预处理(暂时未详细阐述,会在以后某个时间段详细论述...
  • 机器学习实战书中没有具体推理权重向量θ更新的过程,仅仅是下面三行代码 (1)A=x.θ; (2)E=sigmoid(A)-y; (3)θ:=θ-α.x'.E,x'表示矩阵x的转置。 为什么这样更新??? ...
  • 由于原始数据值的范围差异很大,这可能导致具有相同权重的要素,因为数值范围的不同而造成权重的不一致,为此将特征范围归一化,可使得,每个特征对最终距离的贡献大致成比例。 2、归一化的好处 1】加快了梯度下降...
  • 吴恩达 --机器学习01

    2019-05-05 23:19:26
    监督学习 vs 无监督学习 以预测房价为例,给定...构建函数描述输入xi的集合和y的最终关系,为了指导权重的变化,使得预测值和真实值之间的差距尽可能 的缩小,构建的函数与真实值作差, L1 loss或L2 loss。 ...
  • 机器学习中的训练集、验证集、测试集训练集验证集测试集参考 训练集 训练集用来训练模型,即确定模型的权重和偏置这些参数,通常我们称这些参数为学习参数。 验证集 而验证集用于模型的选择,更具体地来说,验证集并...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 123
精华内容 49
关键字:

机器学习求权重