精华内容
下载资源
问答
  • 几种损失函数比较

    千次阅读 2018-12-08 12:38:39
    损失函数(Loss Function)是用来评估模型好坏程度,即预测值f(x)与真实值的不一致程度,通常表示为L(Y, f(x))的个非负的浮点数。比如你要做个线性回归,你拟合出来的曲线不会和原始的数据分布是完全吻合(完全...

    1. 综述

    损失函数(Loss Function)是用来评估模型好坏程度,即预测值f(x)与真实值的不一致程度,通常表示为L(Y, f(x))的一个非负的浮点数。比如你要做一个线性回归,你拟合出来的曲线不会和原始的数据分布是完全吻合(完全吻合的话,很可能会出现过拟合的情况),这个差距就是用损失函数来衡量。那么损失函数的值越小,模型的鲁棒性也就越好,对新数据的预测能力也就越强。

    通常提到损失函数,我们不得不提到代价函数(Cost Function)及目标函数(Object Function)。

    损失函数(Loss Function) 直接作用于单个样本,用来表达样本的误差

    代价函数(Cost Function)作用于整个训练集,是整个样本集的平均误差,对所有损失函数值的平均

    目标函数(Object Function)是我们最终要优化的函数,也就是代价函数+正则化函数(经验风险+结构风险)

     minJ(\theta )=\frac{1}{n}\sum_{i=1}^{n}L(y_{i}, f(x_{i};\theta)) + \lambda \Phi (\theta )

    其中,第一部分是代价函数,L代表损失函数;第二部分是正则化函数(也可以称为惩罚项),可以试L1,也可以试L2或者其他正则函数。整个表达式是要找到是目标函数最好的值。

    2. 损失函数

    0-1损失函数(0-1 Loss Function)主要用于感知机

    平方损失函数(Quadratic Loss Function)主要用于最小二乘法(OLS)

    绝对值损失函数(Absolute Loss Function)

    对数损失函数(Logarithmic Loss Function,Cross Entropy Loss Function, Softmax Loss Loss Function)主要用于Logistic回归与Softmax分类

    指数损失函数(Exponential Loss Function)主要用于Adaboost集成学习算法

    铰链损失函数(Hinge Loss Function)主要用于支持向量机(SVM)

    2.1 0-1损失函数(0-1 Loss Function)

    L(y,f(x))=\left\{\begin{matrix} 1, y \neq f(x)\\ 0, y = f(x) \end{matrix}\right.

    当预测错误时,损失函数结果为1;当预测正确时,损失函数为0。该预测并不考虑具体的误差程度,直接进行二值化。

    优点:稳定的分类面,不连续,所以不可导,但是次梯度可导

    缺点:二阶不可导,有时候不存在唯一解

    2.2 平方损失函数(Quadratic Loss Function)

    L(y, f(x))=(y-f(x))^2

    预测值与实际值的差的平方。

    优点:容易优化(一阶导数连续)

    缺点:对outlier点敏感,得不到最优的分类面

    2.3 绝对值损失函数(Absolute Loss Function)

    L(y, f(x))=|y-f(x)|

    与平方损失函数类似,去实际值与测试值的差值的绝对值,但是不会被放大。

    2.4 对数损失函数(Logarithmic Loss Function)

    L(y, p(y|x)) = -log\ p(y|x)

    对数损失函数用到了极大似然估计的思想。P(Y|X)表示在当前模型上,样本X的预测值为Y的概率,也就是说对于样本X预测正确的概率。由于统计极大似然估计用到概率乘法,为了将其转为假发,对其取对数即可方便展开为加法;由于是损失函数,预测正确的概率应该与损失值成反比,这里对概率取反得到log(\frac{1}{p(y|x)}),转化一下可以得到-log\ p(y|x)

    优点:稳定的分类面,严格凸,且二阶导数连续。

    2.5 指数损失函数(Exponential Loss Function

    L(y,f(x))=e^{-yf(x)}

    学过Adaboost的知道它是前向分步加法算法的特例,是一个加和模型,损失函数就是指数函数。

    2.6 铰链损失函数(Hinge Loss Function)

    L(w, b)=max\begin{Bmatrix} 0,1-yf(x) \end{Bmatrix},其中y=\pm 1f(x)=wx+b

    Hinge Loss function 一般在分类算法使用的分类函数,尤其使用于SVM。

    优点:稳定的分类面,凸函数。可以极大化分类间隔。

    3. 代价函数

    3.1 均方误差(Mean Square Error)

    MSE=\frac{1}{n}\sum_{i=1}^{n}(y_{i}-f(x_{i}))^2

    均方误差是指参数估计值与参数真值之差平方的期望值,MSE用来评估模型的好坏程度,MSE越小说明预测模型精确度越高。

    通常用来做回归问题的代价函数。

    3.2 均方根误差(Root Mean Square Error)

    RMSE=\sqrt{\frac{1}{n}\sum_{i=1}^{n}(y_{i}-f(x_{i}))^2}

    均方根误差是均方的算术平方根,能够直观的观察预测值与真实值直接的差距。

    通常用来作为回归算法的性能指标。

    3.3 平均绝对误差(Mean Absolute Error)

    MAE=\frac{1}{n}\sum_{i=1}^{n}|y_{i}-f(x_{i})|

    平均误差是绝对误差的平均值,平均绝对误差能更好的反应预测值与实际值的实际误差情况。

    通常用来作为回归算法的性能指标。

    3.4 交叉熵代价函数(Cross Entry)

    H(p,q)=-\sum_{i=1}^{n}p(x_{i})log\ q(x_{i})

    其中p(x)是真实分布的概率,q(x)是模型通过数据计算出来的概率估计。

    交叉熵是用来评估当前训练得到的概率分布于真实分布的差异情况,减少交叉熵损失就是在提高模型的预测的准确率。

    通常用来作为分类问题的代价函数。

    4. 正则化

    4.1 L1正则化

    L1正则化假设模型的先验概率分布服从拉普拉斯分布;

    \min_{w}E=H(x, w) + \lambda \left \| W \right \|_{2}^{2}

    --求解略复杂;

    --能够得到稀疏解

    4.2 L2正则化

    L2正则化假设模型的先验概率分布服从高斯分布;

    \min_{w}E=H(x,w)+\lambda \left | w \right |

    --简单有效

    --便于求解

    -- 最常用

    5. 选择好的损失函数

    什么样的损失函数时好的损失函数,那么多的损失函数,有没有一定的选择准则?

     minJ(\theta )=\frac{1}{n}\sum_{i=1}^{n}L(y_{i}, f(x_{i};\theta)) + \lambda \Phi (\theta )

    还是需要考虑你的具体要解决的问题及样本情况。可以简单遵循几个准则:

    • L梯度需要有界,鲁棒性要有保障
    • 将L1作为L的渐近线,稳定的分类边界
    • 大分类间隔,保证泛化能力
    • 选择正确的正则化方法(一般选择L2)

    6. 参考文献

    [1] https://www.cnblogs.com/lliuye/p/9549881.html

    [2] https://blog.csdn.net/leo_xu06/article/details/79010218

    [3] https://blog.csdn.net/weixin_37136725/article/details/79291818

    展开全文
  • 函数参数的几种形式及其相关

    千次阅读 2019-01-11 19:56:06
    形参即形式参数,就是在定义函数时括号中指定的参数,本质就是个名字 实参即实际参数,指的是在调用函数的时候传入的参数,是个实际的值 在调用函数式就会自动把形参(变量名)和实参(值)进行绑定, 在函数调用结束...

    形参与实参
            形参即形式参数,就是在定义函数时括号中指定的参数,本质就是一个名字
            实参即实际参数,指的是在调用函数的时候传入的参数,是一个实际的值
        在调用函数式就会自动把形参(变量名)和实参(值)进行绑定,
        在函数调用结束之后绑定关系就解除了

    """
    def func1(a,b): # a,b就是形参 a = 1,b = 2
        print(a)
        print(b)

    func1(1,2) # 1,2就是实参

    根据调用阶段 参数分为两类 形参和实参
    所以对应的 位置参数也有两种:
        位置形参

        位置实参
    位置,其实指的是顺序,从左往右来定义的参数就是位置(顺序)参数
    需要注意的是:
        只要是定义了的位置形参都必须被传值
        位置形参的数量与位置实参的数量必须一致,不能多传,也不能少传
        实参会按照传入的位置依次赋值给形参

    def func(a,b,c):# abc都是位置形参
        print(a,b,c)

    func(2,1,3) # 1,2,3都是位置实参

    def register(name,passwod,sex):
        print("my name is %s pwd:%s sex:%s" % (name,passwod,sex))

    register("123","rose","woman")

    3.关键字参数
        关键字实参
        在调用函数时,指名道姓的为形参赋值就称之为关键字参数
    其优点是:
        可以打破传入参数的顺序 可以不与形参顺序相同
    注意:
    1.不管以什么样的方式传值,每一个形参都必须被传值
    2.关键字参数必须位于位置参数的后面
    3.不能为同一个参数传多次值
    4.使用关键字传参时,实参的名字必须与形参的名字匹配

    到底是位置参数还是关键字参数 由实参决定

     def func(a,b,c):
         print(a)
         print(b)
         print(c)

     func(1,2,c = 3) # 与位置参数没区别
     func(1,2,a = 10) # 重复为a传值了两次
     func(c = 3,1,2) # 语法错误 关键字参数出现在了位置参数的前面
     func(a = 1,c = 3,b = 2) # 可以打破位置参数的顺序限制
     def register(name,pwd):
        print("name is",name)
        print("password is",pwd)
    register(pwd="123",name="bgon")
    register("jack",pwd="321")

    可以不用完全按照顺序来传值
    open("今日内容","r",encoding="utf-8")

    默认形参
         在定义时,就已经为形参指定了一个值,那这个形参就称之为默认形参
        特点:
            在调用时可以不用为默认形参传值,使用这个参数时就是默认值
            当然也可以传值,这样的话内部使用就是你传入的值
        场景:
            当函数中的某一形参经常出现重复的值时,就可以将其定义为默认形参,
            可以简化调用代码

    需要注意
        1.默认形参必须放在非默认形参的后面
        2.默认形参的值在定义时就已经固定了
        3.不应该将默认形参的默认值设置为一个可变类型,
        会导致 每次函数调用都共用同一个默认参数,我们应该将函数设计为独立的功能 每次调用互不干扰
        只能是 int float str tuple

     def reg(name,age,sex="woman"):
         print(name,age,sex)

     reg("rose",18)
     reg("kairy",20)
     reg("maria",39)
     reg("lili",78)
     reg("egon",38,"man")

     def reg1(name,sex,hobby,li=()):
         print(name,sex)
         print(li)

     reg1("bgon","man","music")
     reg1("cgon","man","play")

     def reg1(name,sex,hobby):
         print(name,sex)
         print(hobby)

     reg1("bgon","man",["music","play"])

     def fun(b,c,a=10):
         pass

     x = 1
     def func2(a,b=x):
         print(a,b)

     x = 100
     func2(20)

    可变长参数指的是,可以传任意个数的实参
    传入实参是为了给形参来使用,那就意味,必须让形参也具备可以接受任意个数的实参的能力
    也就是*和**

    *的使用
        带*的形参
        带*的形参表示可以接受任意个数的实参,接收到的实参会被打包成元组类型
        形参的名字可以随意,但是建议用args 是arguments的缩写

        带*的实参
        在实参前面加*,会自动将*后的值,打散("abc" 打散 成了 "a","b","c")

        带*的形参不能接收关键字实参

    可变长形参与位置形参混合使用
        1.当可变长形参出现在了位置形参的前面时,那么后面的位置形参必须以关键字实参来传入
        2.当可变长形参出现在位置形参后面,会先按照顺序给前面位置形参赋值最后剩余的就赋值给可变长args

    **的使用
        形参中如果带有**,会把关键字实参打包成字典类型传入
        只能接收多出来的关键字实参

        实参中带**,会把**后的字典(也必须是字典类型)打散,成关键字实参(**{"a":1} 打散为 a = 1)

    * 和 **可以为函数预留扩展空间,后期可以根据需求增加参数,而且旧的函数调用方式也不会出现问题
    简单地说就是提高函数的扩展性

    ""
     def func(*args):
         print(args)
         pass

     func(1)
     func(1,2)
     func(1,2,3)

     def func(a,b,c,d,e):
         print(a,b,c,d,e)

     func(1,2,*[0,9,8]) # func(1,2,a,b,c)

     iterable 可迭代的  只要是可以被for in 循环使用的都是可迭代 字符串 列表 元组  字典 集合


     func(a=1)
     func(a=1,b=2)
     func(a=1,b=2,c=3)

     位置形参与 可变长形参混合使用
     当可变长形参出现在了位置形参的前面时,那么后面的位置形参必须以关键字实参来传入
    def func(*args,a,b):
         print(a,b,args)

     func(1,2,3,4,b=5)
     当可变长形参出现在位置形参后面,会先按照顺序给前面位置形参赋值最后剩余的就赋值给可变长args

     def func(a,b,*args):
         print(a,b,args)

     func(1,2,3,4,5,)

     **不能接收位置实参
     def func(**b):
         print(b)

     func(a = 100,c = "abc")

     先为前面的形参赋值,后续的多余的关键字参数赋值给**
     def func(a,c,**b):
         print(a,c)
         print(b)

     func(1,s = 100,c = "abc")
     def func(c,a=1,**b):
         print(a,c)
         print(b)

     func(1,2)

     def func(a=1,b=2,**kwargs):
         print(a,b,kwargs)

     func(a = -1,b=-2,s = 10)

     实参中带**
     def func(a,b,c):
         print(a,b,c)

     func(**{"a":"rose","b":"woman","c":18}) # func(name="rose",sex="woman")



     print(**{"name":"rose"}) # print(name="rose")

     写一个带有可变长的位置形参函数
     def func(name,pwd,**kwargs):
         if name == "bgon" and pwd == "123":
             if "phone" in kwargs:
                 if kwargs["phone"] == "110":
                     print("登录成功!")
             else:
                 print("请传入手机号验证!")
         else:
             print("登录失败!")

     func("bgon","123")
     func("bgon","123",phone = "110")

     该方式可以接受任意个数的位置实参和关键字实参,
     但要注意顺序,位置实参必须在关键字之前

    def inner(name,sex,age):
        print(name,sex,age)

    def outer(*args,**kwargs):
        print(args)
        print(kwargs)
        inner(*args,**kwargs) # inner(1,2,3,a=10,b=20)

    outer(1,2,3,100,a=10,b=20)

     上述写法 可以将outer接收到的所有参数 原模原样的传给inner函数

     

    展开全文
  • 几种常用的激活函数

    千次阅读 2018-08-30 11:13:35
    1. sigmod函数 函数公式和图表如下图   在sigmod函数中我们可以看到,其输出是在[0,1]这个开区间内,我们可以联想到概率,但是严格意义上讲,不要当成概率。sigmod函数曾经是比较流行的,它可以想象成一个神经元...

    1. 激活函数

    如下图,在神经元中,输入的 inputs 通过加权,求和后,还被作用了一个函数,这个函数就是激活函数 Activation Function。

    1.1 激活函数的作用:

    如果不用激活函数,每一层输出都是上层输入的线性函数,无论神经网络有多少层,输出都是输入的线性组合。 
    如果使用的话,激活函数给神经元引入了非线性因素,使得神经网络可以任意逼近任何非线性函数,这样神经网络就可以应用到众多的非线性模型中。 

    激活函数的主要作用是提供网络的非线性建模能力。如果没有激活函数,那么该网络仅能够表达线性映射,此时即便有再多的隐藏层,其整个网络跟单层神经网络也是等价的。因此也可以认为,只有加入了激活函数之后,深度神经网络才具备了分层的非线性映射学习能力。

    上图中我们对output进行计算(这里i1代表input1,i2代表input2):

    我们将公式转化一下可以得到:

    我们假设outpu=0

    最后我们发现函数的又回到了y=X*W的模式,即线性模式。所以现在神经元的学习能力是非常有限的。解决不了非线性的问题,所以叠加简单的神经网络解决不了非线性的问题。

    1.2 激活函数特性:

    • 可微性: 当优化方法是基于梯度的时候,这个性质是必须的。 
    • 单调性: 当激活函数是单调的时候,单层网络能够保证是凸函数。 
    • 输出值的范围: 当激活函数输出值是 有限 的时候,基于梯度的优化方法会更加 稳定,因为特征的表示受有限权值的影响更显著;当激活函数的输出是 无限 的时候,模型的训练会更加高效,不过在这种情况小,一般需要更小的learning rate。

     

    2. 各种激活函数

    2.1 sigmod函数

     

     

    函数公式和图表如下图

    sigmod函数公式 
    sigmod函数图

    在sigmod函数中我们可以看到,其输出是在[0,1]这个开区间内,我们可以联想到概率,可以被表示做为概率,或用于输入的归一化,代表性的如Sigmoid交叉熵损失函数,但是严格意义上讲,不要当成概率。sigmod函数曾经是比较流行的,它可以想象成一个神经元的放电率,在中间斜率比较大的地方是神经元的敏感区,在两边斜率很平缓的地方是神经元的抑制区。

    当然,流行也是曾经流行,这说明函数本身是有一定的缺陷的。

    1. 当输入稍微远离了坐标原点,函数的梯度就变得很小了,几乎为零。在神经网络反向传播的过程中,我们都是通过微分的链式法则来计算各个权重w的微分的。当反向传播经过了sigmod函数,这个链条上的微分就很小很小了,况且还可能经过很多个sigmod函数,最后会导致权重w对损失函数几乎没影响,这样不利于权重的优化,这个问题叫做梯度饱和,也可以叫梯度弥散(梯度消失)。
    2. 函数输出不是以0为中心的,这样会使权重更新效率降低。因为这会导致后层的神经元的输入是非0均值的信号,这会对梯度产生影响:假设后层神经元的输入都为正(e.g. x>0 elementwise in ),那么对w求局部梯度则都为正,这样在反向传播的过程中w要么都往正方向更新,要么都往负方向更新,导致有一种捆绑的效果,使得收敛缓慢。 当然了,如果你是按batch去训练,那么每个batch可能得到不同的符号(正或负),那么相加一下这个问题还是可以缓解。因此,非0均值这个问题虽然会产生一些不好的影响,不过跟上面提到的 kill gradients 问题相比还是要好很多的。(不过有一种常用的解决方案是,将最终函数值减去0.5)
    3. sigmod函数要进行指数运算,这个对于计算机来说训练效率是比较慢的。

    具体来说,由于在后向传递过程中,sigmoid向下传导的梯度包含了一个 f′(x)f′(x) 因子(sigmoid关于输入的导数),因此一旦输入落入饱和区,f′(x)f′(x) 就会变得接近于0,导致了向底层传递的梯度也变得非常小。此时,网络参数很难得到有效训练。这种现象被称为梯度消失。一般来说, sigmoid 网络在 5 层之内就会产生梯度消失现象。

    此外,sigmoid函数的输出均大于0,使得输出不是0均值,这称为偏移现象,这会导致后一层的神经元将得到上一层输出的非0均值的信号作为输入。 

     

    2.2 tanh函数

    tanh函数公式和曲线如下

    tanh函数公式 

    tanh的变形


    tanh函数图

    tanh是双曲正切函数,tanh函数和sigmod函数的曲线是比较相近的,咱们来比较一下看看。首先相同的是,这两个函数在输入很大或是很小的时候,输出都几乎平滑,梯度很小,不利于权重更新;不同的是输出区间,tanh的输出区间是在(-1,1)之间,而且整个函数是以0为中心的,这个特点比sigmod的好。

    一般二分类问题中,隐藏层用tanh函数,输出层用sigmod函数。不过这些也都不是一成不变的,具体使用什么激活函数,还是要根据具体的问题来具体分析,还是要靠调试的。

     

    2.3 ReLU函数

    ReLU函数公式和曲线如下

    relu函数公式 
    relu函数图

    ReLU(Rectified Linear Unit)函数是目前比较火的一个激活函数,相比于sigmod函数和tanh函数,它有以下几个优点:

    1. Krizhevsky发现使用 ReLU 得到的SGD的收敛速度会比sigmoid/tanh 快很多。有人说这是因为它是linear,而且梯度不会饱和
    2. 计算速度要快很多。ReLU函数只有线性关系,不管是前向传播还是反向传播,都比sigmod和tanh要快很多。(sigmod和tanh要计算指数,计算速度会比较慢)

    当然,缺点也是有的:

    1. ReLU在训练的时候很”脆弱”,一不小心有可能导致神经元”坏死”。举个例子:由于ReLU在x<0时梯度为0,这样就导致负的梯度在这个ReLU被置零,而且这个神经元有可能再也不会被任何数据激活。如果这个情况发生了,那么这个神经元之后的梯度就永远是0了,也就是ReLU神经元坏死了,不再对任何数据有所响应。实际操作中,如果你的learning rate 很大,那么很有可能你网络中的40%的神经元都坏死了。 当然,如果你设置了一个合适的较小的learning rate,这个问题发生的情况其实也不会太频繁。
    2. 我们发现ReLU函数的输出要么是0,要么是正数,这也就是说,ReLU函数也不是以0为中心的函数。

     

    2.4 ELU函数

    ELU函数公式和曲线如下图

    elu函数公式 
    elu函数图

    ELU函数是针对ReLU函数的一个改进型,相比于ReLU函数,在输入为负数的情况下,是有一定的输出的,而且这部分输出还具有一定的抗干扰能力。这样可以消除ReLU死掉的问题,不过还是有梯度饱和和指数运算的问题。

     

    2.5 PReLU函数

    PReLU函数公式和曲线如下图

    prelu公式 
    prelu函数图

    PReLU也是针对ReLU的一个改进型,在负数区域内,PReLU有一个很小的斜率,这样也可以避免ReLU死掉的问题。相比于ELU,PReLU在负数区域内是线性运算,斜率虽然小,但是不会趋于0,这算是一定的优势吧。

    我们看PReLU的公式,里面的参数α一般是取0~1之间的数,而且一般还是比较小的,如零点零几。当α=0.01时,我们叫PReLU为Leaky ReLU,算是PReLU的一种特殊情况吧。

     

    2.6 MAXOUT函数

    maxout网络能够近似任意连续函数,且当w2,b2,…,wn,bn为0时,退化为ReLU。Maxout能够缓解梯度消失,同时又规避了ReLU神经元死亡的缺点,但增加了参数和计算量。

     

    2.7 softmax函数

    softmax--用于多分类神经网络输出

     

    3. 几种激活函数的对比

    sigmod和ReLU

    隐藏层的激活函数有9中激活函数可以选择:Sigmoid,Linear,Tanh,ArchTan,Relu,Parameteric ReLU(PReLU),ELU,SoftPlus和BentLinear

    这里我们在隐藏层分别用sigmod和ReLU,输出层为sigmod。

    1. 数据比较复杂时,mini_batch的值设置的相对大一些,这样每次能覆盖不同的类型,训练的效果会更好。
    2. 在训练次数相同时,ReLU激活函数的训练效果确实优于sigmoid函数。在大量次数(几十万次以上)训练后相差不大。
    3. sigmoid更容易出现过拟合。对于这个实验,隐层神经元为30个的时候,sigmoid会出现过拟合现象,几乎不能分类,在隐层神经元为10个的时候,能够进行部分分类,但是效果比不上ReLU的分类效果。
    4. ReLU在小batch(比如10)时效果不好

    对于ReLU而言,ReLU的特点是,隐层比sigmoid需要的神经元多,学习速率相对要小一点,mini_batch的数量要大一些。

     

    总结:

    总体来看,这些激活函数都有自己的优点和缺点,没有一条说法表明哪些就是不行,哪些激活函数就是好的,所有的好坏都要自己去实验中得到。不同的数据不同的场景不同的模型所需要的是不同的激活函数,而我们所需要做的就是优雅的选出那个最合适的为我们所用。

    参考链接:

    大白话讲解BP算法:【https://blog.csdn.net/zhaomengszu/article/details/77834845

    RNN学习中长期依赖的三种机制:【https://zhuanlan.zhihu.com/p/34490114

    RNN中为什么用tanh作为激活函数而不是ReLU(其实也是可以用ReLU,比如IRNN):【https://www.zhihu.com/question/61265076

    常用的激活函数:【https://www.jianshu.com/p/22d9720dbf1a

    展开全文
  • Python Lambda函数几种使用方法

    千次阅读 2019-06-25 14:27:57
    在进行编程时,一般我们会给函数或者变量起个名字,该名称是用于引用或寻址函数变量。但是有个低调的函数,你不需要赋予它名字,因此该函数也叫匿名函数。该函数就是Python中的Lambda函数,下面就来为大家...

    文章转自:https://mp.weixin.qq.com/s/-jW8ODLsUgfoWdx9ZFW3LQ

    在进行编程时,一般我们会给一个函数或者变量起一个名字,该名称是用于引用或寻址函数变量。但是有一个低调的函数,你不需要赋予它名字,因此该函数也叫匿名函数。该函数就是Python中的Lambda函数,下面就来为大家解析lambda函数的基本使用方法。
    为什么要使用Python Lambda函数?
    匿名函数可以在程序中任何需要的地方使用,但是这个函数只能使用一次,即一次性的。因此Python Lambda函数也称为丢弃函数,它可以与其他预定义函数(如filter(),map()等)一起使用。相对于我们定义的可重复使用的函数来说,这个函数更加简单便捷。
    如何在Python中编写Lambda函数?
    Lambda函数是使用lambda运算符创建的,其语法如下:
    语法: lambda参数:表达式
    Python lambda函数可以包含任意多的参数,但它只有一个表达式。输入或参数可以从0开始。就像任何其他函数一样,lambda函数也可以是没有输入的。下面为大家举个例子:假如我们计算一个数的平方,则程序为:

    a = lambda x: x*x 
    print(a(3)
    

    输出结果为:9
    相应的,如果我们要计算两个数相乘,则:

    a = lambda x,y: x*y 
    print(a(3,7))
    
    

    输出结果为:21
    在这两个例子中,第一个示例lambda函数只使用一个表达式,而第二个示例有两个参数。而且这两个函数都有一个表达式后跟参数。因此有多种逻辑关系表达式的时候不能使用lambda函数。
    匿名函数加速Python运行
    在比较所需的代码量之前,让我们首先记下正常函数的语法,并将其与前面描述的lambda函数进行比较。Python中的任何普通函数都是使用def关键字定义的,具体语法如下所示:
    def function_name(参数):
    statement(s)
    因此lambda函数所需的代码量远远少于普通函数,也就是说使用Lambda可以精简代码,加速Python程序运行。让我们举个例子对比一下:

    #——————————一般函数
    def my_func(x):
        return x * x 
    print(my_func(3))
    #————————Lambda函数
    a = lambda x,y: x*y 
    print(a(3,7))
    

    在上面的示例中,我们需要在my_func中使用return语句来计算3的平方值。相反,lambda函数不使用此return语句,因此Lambda函数计算的速度快于my_func函数。
    Python Lambda函数的几种使用方法
    示例一:定义一个普通的python函数并嵌入Lambda,函数接收传入的一个参数x。然后将此参数添加到lambda函数提供的某个未知参数y中求和。只要我们使用new_func(),就会调用new_func中存在的lambda函数。每次,我们都可以将不同的值传递给参数。

    def new_func(x):
        return(lambda y:x + y)
    t = new_func(3)
    u = new_func(2)
    print(t(3))
    print(u(3))
    

    输出结果为:6,5
    示例二:Lambda函数+filter函数
    filter()方法用于根据一定的条件对给定的列表进行过滤。使用示例如下:

    my_list = [2,3,4,5,6,7,8] 
    new_list = list(filter(lambda a:(a / 3 == 2),my_list))
    print(new_list)
    

    输出结果为:[6]。
    此示例中my_list是一个列表,它作为参数传递给filter函数。此函数使用lambda函数检查列表中的值是否满足除以3等于2的条件,输出列表中满足条件的值。
    示例三:Lambda函数+map函数
    Python中的map()函数是一个将给定的列表的值依次在所定义的函数关系中迭代并返回一个新列表。例如:

    my_list = [2,3,4,5,6,7,8] 
    new_list = list(map(lambda a:(a / 3!= 2),li))
    print(new_list)
    

    输出结果为:[真,真,真,真,假,真,真]
    示例四:Lambda函数+reduce函数
    reduce() 函数会对参数序列中元素进行累积。使用示例如下:

    from functools import reduce 
    reduce(lambda a,b:a + b,[23,21,45,98])
    

    输出结果为:187
    在这里插入图片描述

    参考
    https://medium.com/edureka/python-lambda-b84d68d449a0

    展开全文
  • 1. 最常规的用法: ... //新建个按钮 QPushButton * btn = new QPushButton(this); btn->setText("设置"); //将信号和槽连接 其中btnclicked()为自定义的槽函数 connect(btn, SIGNAL(clicked()), th...
  • 、调取参数 直接调取当前js中的方法, 调取参数that.bindViewTap();   二、跳转页面 navigateTo: function () { wx.navigateTo({ url: '../page4/page4' }); }, 全局变量使用方法 a.js var app = getApp()...
  • 首先给出结论:损失函数和代价函数是同个东西, 目标函数个与他们相关但更广的概念,对于目标函数来说在有约束条件下的最小化就是损失函数(loss function)。 举个例子解释一下:(图片来自Andrew Ng Machine...
  • javascript定义函数几种方式

    千次阅读 2009-08-19 10:43:00
    函数的JavaScript代码则在每次调用构造函数时只需被解析一次和编译一次。    在JavaScript1.1中,可以使用构造函数Function()来定义函数,在JavaScript1.2和其后的版本中,还可以使用函数直接量来构造函数。...
  • SVM几种函数的对比分析以及SVM算法的优缺点

    万次阅读 多人点赞 2019-04-25 14:54:00
    SVM核函数是用来解决数据线性不可而提出的,把数据从源空间映射到目标空间(线性可空间)。 SVM中核函数的种类 1、线性核 优点: 方案首选,奥卡姆剃刀定律 简单,可以求解较快个QP问题 可解释性强:...
  • 本文探讨拉链表解决哈希冲突的方式和几种常见的散列函数。  首先,什么是散列表?  对于个数组,我们在O(1)时间复杂度完成可以完成其索引的查找,现在我们想要存储个key value的键值对,我们可以根据key生成...
  • 几种javascript函数定义的差别

    千次阅读 2010-03-07 13:36:00
    javascript函数的定义1:调用关键字function来构造,如: function distance(x1,x2,y1,y2) { var dx=x2-x1; var dy=y2-y1; return Math.sqrt(dx*dx+dy*dy); } 2:使用Function()构造函数
  • 几种javascript函数定义的区别

    万次阅读 2007-12-18 17:23:00
    1:调用关键字function来构造 如: function distance(x1,x2,y1,y2) ...{ var dx=x2-x1; var dy=y2-y1; return Math.sqrt(dx*dx+dy*dy); } 2:使用Function()构造函数 如: var f=new Funct
  • C++中几种读取数据的函数的用法

    万次阅读 2017-11-25 21:58:45
    (我用Eclipse也跑过遍了) 1.cin简介 cin是C++编程语言中的标准输入流对象,即istream类的对象。cin主要用于从标准输入读取数据,这里的标准输入,指的是终端的键盘。此外,cout是流的对象,即ostream类的对象...
  • 本文将带领你同了解四种函数对象创建方法和两种函数对象传递方法,并剖析其各自的优劣之处。 摘要:作为函数式编程的核心,函数对象的创建和传递都有不同的实现方法。本文将带领你同了解四种函数对象创建方法和...
  • 绘制函数调用关系图对理解大型程序大有帮助。我想大家都有过一边读源码(并在头脑中维护个调用栈),一边在纸上画函数调用关系,然后整理成图的经历。...下面举出我知道的几种免费的分析C/C++函数调用关系的工具
  • java中的锁有哪几种

    万次阅读 2018-01-02 15:50:57
    本文内容来自百度百科 https://zhidao.baidu.com/question/1610001582034812547.html、公平锁/非公平锁公平锁是指多个线程按照申请锁的顺序来获取锁。...对于Java ReentrantLock而言,通过构造函数
  • 线性整流函数(Rectified Linear Unit, ReLU),又称修正线性单元,是一种人工神经网络中常用的激活函数(activation function),通常指代以斜坡函数及其变种为代表的非线性函数。 很显然,在正区域内,斜率为1,...
  • 函数的图象是数学,对于研究函数的单调性、奇偶性以及最值(值域)、零点有举足轻重的作用,但是很多...1、首先,观察是否是基本初等函数(也就是我们在课本中学过的那函数),如果是,那就可以直接画;2、如果...
  • 例题:目前人民币共有以下几种面值(不包括角和):1元 2元 5元 10元 20元 50元 100元 编写函数计算金额"X"需要多少张面值为n 元的纸币。 代码如下: /*代码分析:在主函数中输入个金额值,调用该函数。计算...
  • hive的3自定义函数

    千次阅读 2020-04-21 00:16:35
    hive自定义函数 1 自定义函数 1.1 为什么需要自定义函数 hive的内置函数满足不了所有的业务需求。 hive提供很多的模块可以...的输入输出。(最常用的)。 UDTF:用户自定义表生成函数。user defined table...
  • c语言中,变量按作用域角度分为局部变量和全局变量。 1、局部变量是在函数内部或个代码块中定义的变量,只能在被函数和代码块范围内有效。如: void test() { int b = 20; // b是个局部变量,在test...
  • C++ 六特殊成员函数

    千次阅读 2015-04-14 21:17:14
    C++定义了几种只能作为类成员函数说明的函数,它们称为“特殊成员”函数。这些函数影响着给定类对象创建、删除、拷贝以及转换成其它类型对象的方法。这些函数的另个重要的特性是它们可以由编译器隐含调用。 ...
  • 确保线程安全的几种方法

    万次阅读 2017-07-10 18:12:43
    本文首先对线程进行简单的介绍,然后介绍几种保证线程安全的方法。
  • C++ 模板函数查找

    千次阅读 2018-12-30 21:49:54
    C++ 模板函数查找 简单二查找 ...算法的思路比较简单,在这里主要是作为一个C++模板函数一次练习。 下面是百度百科上对二查找查找过程的介绍,忘记了的同学可以看看。 首先,假设表...
  • 递归函数个例子

    万次阅读 多人点赞 2017-05-14 17:03:52
    个人赶着鸭子去每个村庄卖,每经过个村子卖去所赶鸭子的一半又只。 这样他经过了七个村子后还剩两只鸭子,问他出发时共赶多少只鸭子?经过 每个村子卖出多少只鸭子?*/#include int q(int duck,int village)/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 599,322
精华内容 239,728
关键字:

一次函数分为哪几种