精华内容
下载资源
问答
  • 线性规划目标函数及基本不等式常见类型梳理.doc
  • 线性规划目标函数与基本不等式常见类型梳理.doc
  • 目标函数常见解法

    千次阅读 2018-12-12 20:27:06
    如何求解目标函数 简介 相信大家在写程序的时候,尤其是一些机器学习算法的时候,都会遇到将自己的目标函数使用矩阵形式表达的情况。...此外,本文还包括一些常见的矩阵形式的目标函数的解法。 ...

    如何求解目标函数

    简介

    相信大家在写程序的时候,尤其是一些机器学习算法的时候,都会遇到将自己的目标函数使用矩阵形式表达的情况。大多数时候,我们写目标函数都是以\sum的形式递归的计算,但是写程序的时候一般输入都是所有的数据,如numpy储存的数组,因此需要转化为矩阵形式。这里简单介绍一下常用的方法以及函数(tensorflow),希望有所收获。

    此外,本文还包括一些常见的矩阵形式的目标函数的解法。

    常用函数

    1:numpy.linalg.norm(x, ord=None, axis=None, keepdims=False)

    numpy.linalg.norm(x, ord=None, axis=None, keepdims=False)[source]
    
    '''
       Parameters:	
                x : array_like Input array. If axis is None, x must be 1-D or 2-D.
    
                ord : {non-zero int, inf, -inf, ‘fro’, ‘nuc’}, optional Order of 
                      the norm (see table under Notes). inf means numpy’s inf object.
    
                axis : {int, 2-tuple of ints, None}, optional  If axis is an integer, it             
                       specifies the axis of x along which to compute the vector norms. 
                       If axis is a 2-tuple, it specifies the axes that hold 2-D matrices, 
                       and the matrix norms of these matrices are computed. If axis is None 
                       then either a vector norm (when x is 1-D) or a matrix norm (when x 
                       is 2-D) is returned.
    
                keepdims : bool, optional If this is set to True, the axes which are normed 
                           over are left in the result as dimensions with size one. With this 
                           option the result will broadcast correctly against the original x.
    
    
      Returns:	
                n : float or ndarray
    '''

    tf.linalg.norm主要用于计算向量的范数。上面的代码摘抄自numpy官网https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.linalg.norm.html,仅仅看注释还是很难理解每个参数的定义,下面我简单在介绍一下:

    X是输入,一般就是一个多维的ndarray,ord代表范数的类型,axis代表怎么看待每一个向量,axis=1表示按行向量处理,求多个行向量的范数;axis=0表示按列向量处理,求多个列向量的范数;axis=None表示矩阵范数。keepdims代表是否保持结果维度不变。

    这里主要根据一个例子说明上面几个属性的作用:

    np.linalg.norm(x)使用的ord=None,axis=None,keepdim=False说明做的是矩阵二范数(默认),sqrt(0^2+3^2+4^2+1^2+6^2+4^2)=8.83,与结果比较可以看出是正确的。

    当使用axis=1时,代表按行向量处理,因此计算[0,3,4]和[1,6,4]的二范数,分别是5和7.28.

    当使用axis=0时,代表按列向量处理,因此存在三个向量[0,1],[3,6],[4,4],因此可以得到对应的三个值。

    1.1 欧氏距离

    使用上面的函数可以求解各类距离函数,如欧式距离,python代码如下:

    def calc_l2_norm(feature1, others):
        diffs = feature1 - others
        dists = np.linalg.norm(diffs, axis=1)
        return dists

    上面的函数中feature1代表一个n维的数据,others代表1个或者多个n维的数据,上面的函数可以计算feature1和所有others的欧氏距离。

    1.2 汉明距离

    def calc_hammingDist(request, retrieval_all):
        K = retrieval_all.shape[1]
        distH = 0.5 * (K - np.dot(request, retrieval_all.transpose()))
        return distH

    汉明距离可以近似使用内积进行替换,如下公式,那么使用内积进行计算的汉明距离公式如上。

    1.3 余弦距离

    def calc_cosineDist(request, retrieval_all):
        numerator = np.dot(request, retrieval_all.transpose())
        denominator = np.linalg.norm(request) * np.linalg.norm(retrieval_all, axis=1)
        return numerator/denominator

    上面的公式不能解决0/0的问题,当0/0的时候结果是nan,因此需要做一些处理:

    ​
    def calc_cosineDist(request, retrieval_all):
        numerator = np.dot(request, retrieval_all.transpose())
        denominator = np.linalg.norm(request) * np.linalg.norm(retrieval_all, axis=1)
        index = [idx for idx in np.where(numerator == 0)[0] if np.where(denominator == 0)[0]]
        result[index] = 1
    return result

     其中第三行的公式就是将分子,分母都是0的结果置为1,因此分为为0肯定存在有至少一个向量的模长为0,也就是0向量,所以分子肯定也为0。

    2:tf.reduce_sum()

    tf.reduce_sum(
        input_tensor,
        axis=None,
        keepdims=None,
        name=None,
        reduction_indices=None,
        keep_dims=None
    )
    '''
        Args:
            input_tensor: The tensor to reduce. Should have numeric type.
            axis: The dimensions to reduce. If `None` (the default),
                  reduces all dimensions. Must be in the range
                  '[-rank(input_tensor), rank(input_tensor))'.
            keepdims: If true, retains reduced dimensions with length 1.
            name: A name for the operation (optional).
            reduction_indices: The old (deprecated) name for axis.
            keep_dims: Deprecated alias for `keepdims`.
        Returns:
            The reduced tensor, of the same dtype as the input_tensor.
    
        Example:
            x = tf.constant([[1, 1, 1], [1, 1, 1]])
            tf.reduce_sum(x)  # 6
            tf.reduce_sum(x, 0)  # [2, 2, 2]
            tf.reduce_sum(x, 1)  # [3, 3]
            tf.reduce_sum(x, 1, keepdims=True)  # [[3], [3]]
            tf.reduce_sum(x, [0, 1])  # 6
    '''

    3:矩阵的迹

    矩阵的点积(element-wise multiply)可以写成矩阵相乘的迹的形式,注意这里是矩阵的转置相乘的结果。

    因为矩阵的F范数的平方等于矩阵每个元素的平方和,所以也可以写成矩阵的迹的形式。对于向量来说,我们已经知道向量x的二范数的平方等于x'x,其中x'代表x的转置。因此,遇到上述的对应位置元素相乘的式子,可以转化为矩阵的迹的形式。

    4:矩阵的逆

    求矩阵的逆需要大约O(N^{3})的时间复杂度,但是存在一种特殊的矩阵,也就是正交矩阵,正交阵的逆矩阵等于矩阵的转置。

    除此之外,存在一些关于矩阵的重要性质:

    实对称矩阵的特征向量相互正交;

    实对称矩阵是半正定的; 

    5:F范数

    目标函数里面可能存在F范数,如果要对目标函数求梯度的话,可以首先转化为Tr()迹的形式,然后根据求导法则进行求导。

    参考:

    https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.linalg.norm.html

    https://blog.csdn.net/hqh131360239/article/details/79061535

    https://www.cnblogs.com/devilmaycry812839668/p/9352814.html

    https://blog.csdn.net/txwh0820/article/details/46392293

    6:one-hot向量

    one-hot编码的意思很简单,就是一个c维的向量,只存在一位是1,其余维都为0。举个简单的例子,如果想要分类MNIST手写体数字的话,我们可以为每一张图像生成一个label,该label就是one-hot形式的,如果该数字是2,那么one-hot编码为{0,0,1,0,0,0,0,0,0,0}。假设现在存在y∈(0,1)^{c},X∈R^{n*c},那么Xy = X_{k},满足y_{k} = 1。换句话说,如果对于一个c维的列向量y,它的第k位是1,那么一个矩阵X乘以y的结果就是X的第k列。

    7:Orthogonal Procrustes problem

    关于该问题的描述,请查看https://en.wikipedia.org/wiki/Orthogonal_Procrustes_problem,简单的说,就是要找到一个正交基,使得一个将某个矩阵A进行一个变换之后,去和另一个矩阵B对其。

    上面的公式就是该问题的一般描述。这里,我说一下该问题的实际用处,如下是哈希编码学习的一个目标函数:

    其中V是连续域R下的矩阵,B是{0,1}的哈希编码矩阵,V∈R^{n*d}​​​​​​, B∈(0,1)^{n*k},希望找到一个正交的矩阵R使得B和V尽可能的一致,该问题的解法就是:

    M = BA^{T},使用SVD分解M,结果R=UV^{T}

    参考:

    https://en.wikipedia.org/wiki/Orthogonal_Procrustes_problem

    8:tf.matmul和tf.multiply的区别

    很多算法需要用到矩阵的乘法,如果你使用的是tensorflow作为深度学习框架的话,就离不开tf.matmul和tf.multiply,他们的区别主要在于tf.multiply只能应用element-wise的乘法上,也就是元素之间的乘法,而tf.matmul适用于矩阵乘法,详情看如下代码:

    import tensorflow as tf
    import numpy as np
    
    # matmul
    inputs = tf.placeholder(tf.int32,[2,3])
    inputs2 = tf.placeholder(tf.int32, [3,1])
    result = tf.matmul(inputs, inputs2)
    temp = np.array([[1,2,3],[4,5,6]])
    temp2 = np.ones((3,1))
    
    
    with tf.Session() as sess:
        print(sess.run(result, feed_dict={inputs:temp, inputs2:temp2}))

    结果:

     

     

    import tensorflow as tf
    import numpy as np
    
    # multiply
    inputs = tf.placeholder(tf.int32,[2,3])
    inputs2 = tf.placeholder(tf.int32, [3,1])
    result = tf.multiply(inputs, inputs2)
    temp = np.array([[1,2,3],[4,5,6]])
    temp2 = np.ones((3,1))
    
    
    with tf.Session() as sess:
        print(sess.run(result, feed_dict={inputs:temp, inputs2:temp2}))

    结果:

    换成dimension一致之后:

     

    import tensorflow as tf
    import numpy as np
    
    # multiply
    inputs = tf.placeholder(tf.int32,[2,3])
    inputs2 = tf.placeholder(tf.int32, [2,3])
    result = tf.multiply(inputs, inputs2)
    temp = np.array([[1,2,3],[4,5,6]])
    temp2 = np.ones((2,3))
    
    
    with tf.Session() as sess:
        print(sess.run(result, feed_dict={inputs:temp, inputs2:temp2}))

    结果:

     

     

    展开全文
  • 目标函数、损失函数、代价函数

    千次阅读 2018-04-21 19:31:48
    目标函数、损失函数、代价函数http://www.cnblogs.com/Belter/p/6653773.html注:代价函数(有的地方也叫损失函数,Loss Function)在机器学习中的每一种算法中都很重要,因为训练模型的过程就是优化代价函数的过程...
    
    

    http://www.cnblogs.com/Belter/p/6653773.html

    注:代价函数(有的地方也叫损失函数,Loss Function)在机器学习中的每一种算法中都很重要,因为训练模型的过程就是优化代价函数的过程,代价函数对每个参数的偏导数就是梯度下降中提到的梯度,防止过拟合时添加的正则化项也是加在代价函数后面的。在学习相关算法的过程中,对代价函数的理解也在不断的加深,在此做一个小结。

     

    1. 什么是代价函数?


    假设有训练样本(x, y),模型为h,参数为θ。h(θ) = θTx(θT表示θ的转置)。

    (1)概况来讲,任何能够衡量模型预测出来的值h(θ)与真实值y之间的差异的函数都可以叫做代价函数C(θ),如果有多个样本,则可以将所有代价函数的取值求均值,记做J(θ)。因此很容易就可以得出以下关于代价函数的性质:

    • 对于每种算法来说,代价函数不是唯一的;
    • 代价函数是参数θ的函数;
    • 总的代价函数J(θ)可以用来评价模型的好坏,代价函数越小说明模型和参数越符合训练样本(x, y);
    • J(θ)是一个标量;

    (2)当我们确定了模型h,后面做的所有事情就是训练模型的参数θ。那么什么时候模型的训练才能结束呢?这时候也涉及到代价函数,由于代价函数是用来衡量模型好坏的,我们的目标当然是得到最好的模型(也就是最符合训练样本(x, y)的模型)。因此训练参数的过程就是不断改变θ,从而得到更小的J(θ)的过程。理想情况下,当我们取到代价函数J的最小值时,就得到了最优的参数θ,记为:

     

    minθJ(θ)

     

    例如,J(θ) = 0,表示我们的模型完美的拟合了观察的数据,没有任何误差。

    (3)在优化参数θ的过程中,最常用的方法是梯度下降,这里的梯度就是代价函数J(θ)对θ1, θ2, ..., θn的偏导数。由于需要求偏导,我们可以得到另一个关于代价函数的性质:

    • 选择代价函数时,最好挑选对参数θ可微的函数(全微分存在,偏导数一定存在)

     

    2. 代价函数的常见形式


    经过上面的描述,一个好的代价函数需要满足两个最基本的要求:能够评价模型的准确性,对参数θ可微。 

     

    2.1 均方误差

    在线性回归中,最常用的是均方误差(Mean squared error),具体形式为:

     

    J(θ0,θ1)=12m∑i=1m(y^(i)−y(i))2=12m∑i=1m(hθ(x(i))−y(i))2

     

    m:训练样本的个数;

    hθ(x):用参数θ和x预测出来的y值;

    y:原训练样本中的y值,也就是标准答案

    上角标(i):第i个样本

     

    2.2 交叉熵

    在逻辑回归中,最常用的是代价函数是交叉熵(Cross Entropy),交叉熵是一个常见的代价函数,在神经网络中也会用到。下面是《神经网络与深度学习》一书对交叉熵的解释:

    交叉熵是对「出乎意料」(译者注:原文使用suprise)的度量。神经元的目标是去计算函数y, 且y=y(x)。但是我们让它取而代之计算函数a, 且a=a(x)。假设我们把a当作y等于1的概率,1−a是y等于0的概率。那么,交叉熵衡量的是我们在知道y的真实值时的平均「出乎意料」程度。当输出是我们期望的值,我们的「出乎意料」程度比较低;当输出不是我们期望的,我们的「出乎意料」程度就比较高。

     

    在1948年,克劳德·艾尔伍德·香农将热力学的熵,引入到信息论,因此它又被称为香农熵(Shannon Entropy),它是香农信息量(Shannon Information Content, SIC)的期望。香农信息量用来度量不确定性的大小:一个事件的香农信息量等于0,表示该事件的发生不会给我们提供任何新的信息,例如确定性的事件,发生的概率是1,发生了也不会引起任何惊讶;当不可能事件发生时,香农信息量为无穷大,这表示给我们提供了无穷多的新信息,并且使我们无限的惊讶。更多解释可以看这里

     

    J(θ)=−1m[∑i=1m(y(i)log⁡hθ(x(i))+(1−y(i))log⁡(1−hθ(x(i)))]

     

    符号说明同上 

     

    2.3 神经网络中的代价函数

    学习过神经网络后,发现逻辑回归其实是神经网络的一种特例(没有隐藏层的神经网络)。因此神经网络中的代价函数与逻辑回归中的代价函数非常相似:

     

    J(θ)=−1m[∑i=1m∑k=1K(yk(i)log⁡hθ(x(i))+(1−yk(i))log⁡(1−(hθ(x(i)))k)]

     

    这里之所以多了一层求和项,是因为神经网络的输出一般都不是单一的值,K表示在多分类中的类型数。

    例如在数字识别中,K=10,表示分了10类。此时对于某一个样本来说,输出的结果如下:

    复制代码
    复制代码
      1.1266e-004
      1.7413e-003
      2.5270e-003
      1.8403e-005
      9.3626e-003
      3.9927e-003
      5.5152e-003
      4.0147e-004
      6.4807e-003
      9.9573e-001
    复制代码
    复制代码

    一个10维的列向量,预测的结果表示输入的数字是0~9中的某一个的概率,概率最大的就被当做是预测结果。例如上面的预测结果是9。理想情况下的预测结果应该如下(9的概率是1,其他都是0):

    复制代码
    复制代码
       0
       0
       0
       0
       0
       0
       0
       0
       0
       1
    复制代码
    复制代码

    比较预测结果和理想情况下的结果,可以看到这两个向量的对应元素之间都存在差异,共有10组,这里的10就表示代价函数里的K,相当于把每一种类型的差异都累加起来了。

     

    3. 代价函数与参数


    代价函数衡量的是模型预测值h(θ) 与标准答案y之间的差异,所以总的代价函数J是h(θ)和y的函数,即J=f(h(θ), y)。又因为y都是训练样本中给定的,h(θ)由θ决定,所以,最终还是模型参数θ的改变导致了J的改变。对于不同的θ,对应不同的预测值h(θ),也就对应着不同的代价函数J的取值。变化过程为:

     

    θ−−>h(θ)−−>J(θ)

     

    θ引起了h(θ)的改变,进而改变了J(θ)的取值。为了更直观的看到参数对代价函数的影响,举个简单的例子:

    有训练样本{(0, 0), (1, 1), (2, 2), (4, 4)},即4对训练样本,每个样本对中第1个数表示x的值,第2个数表示y的值。这几个点很明显都是y=x这条直线上的点。如下图:

    abc

                                                                                                                 图1:不同参数可以拟合出不同的直线

      View Code

    常数项为0,所以可以取θ0=0,然后取不同的θ1,可以得到不同的拟合直线。当θ1=0时,拟合的直线是y=0,即蓝色线段,此时距离样本点最远,代价函数的值(误差)也最大;当θ1=1时,拟合的直线是y=x,即绿色线段,此时拟合的直线经过每一个样本点,代价函数的值为0。

    通过下图可以查看随着θ1的变化,J(θ)的变化情况:

                                                                                                            图2:代价函数J(θ)随参数的变化而变化

      View Code

    从图中可以很直观的看到θ对代价函数的影响,当θ1=1时,代价函数J(θ)取到最小值。因为线性回归模型的代价函数(均方误差)的性质非常好,因此也可以直接使用代数的方法,求J(θ)的一阶导数为0的点,就可以直接求出最优的θ值(正规方程法)。

     

    4. 代价函数与梯度


     梯度下降中的梯度指的是代价函数对各个参数的偏导数,偏导数的方向决定了在学习过程中参数下降的方向,学习率(通常用α表示)决定了每步变化的步长,有了导数和学习率就可以使用梯度下降算法(Gradient Descent Algorithm)更新参数了。下图中展示了只有两个参数的模型运用梯度下降算法的过程。

     

     

     

    下图可以看做是代价函数J(θ)与参数θ做出的图,曲面上的一个点(θ 0, θ 1, J(θ)),有无数条切线,在这些切线中与x-y平面(底面,相当于θ 0, θ 1)夹角最大的那条切线就是该点梯度的方向,沿该方向移动,会产生最大的高度变化(相对于z轴,这里的z轴相当于代价函数J(θ))。

     

    4.1 线性回归模型的代价函数对参数的偏导数

     

     还是以两个参数为例,每个参数都有一个偏导数,且综合了所有样本的信息。

     

    4.2 逻辑回归模型的代价函数对参数的偏导数

    根据逻辑回归模型的代价函数以及sigmoid函数

     

    hθ(x)=g(θTx)

     

     

    g(z)=11+e−z

     

    得到对每个参数的偏导数为

     

    ∂∂θjJ(θ)=∑i=1m(hθ(xi)−yi)xji

     

     详细推导过程可以看这里-逻辑回归代价函数的导数

    作者:zzanswer
    链接:https://www.zhihu.com/question/52398145/answer/209358209
    来源:知乎
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    首先给出结论:损失函数和代价函数是同一个东西,目标函数是一个与他们相关但更广的概念,对于目标函数来说在有约束条件下的最小化就是损失函数(loss function)。

    举个例子解释一下:(图片来自Andrew Ng Machine Learning公开课视频)

     

    上面三个图的函数依次为 f_{1}(x) , f_{2}(x) , f_{3}(x) 。我们是想用这三个函数分别来拟合Price,Price的真实值记为 Y 。

    我们给定 x ,这三个函数都会输出一个 f(X) ,这个输出的 f(X) 与真实值 Y 可能是相同的,也可能是不同的,为了表示我们拟合的好坏,我们就用一个函数来度量拟合的程度,比如:

    L(Y,f(X)) = (Y-f(X))^2 ,这个函数就称为损失函数(loss function),或者叫代价函数(cost function)。损失函数越小,就代表模型拟合的越好

    那是不是我们的目标就只是让loss function越小越好呢?还不是。

    这个时候还有一个概念叫风险函数(risk function)。风险函数是损失函数的期望,这是由于我们输入输出的 (X,Y) 遵循一个联合分布,但是这个联合分布是未知的,所以无法计算。但是我们是有历史数据的,就是我们的训练集, f(X) 关于训练集的平均损失称作经验风险(empirical risk),即 \frac{1}{N}\sum_{i=1}^{N}L(y_{i},f(x_{i})) ,所以我们的目标就是最小化 \frac{1}{N}\sum_{i=1}^{N}L(y_{i},f(x_{i})) ,称为经验风险最小化

    到这里完了吗?还没有。

    如果到这一步就完了的话,那我们看上面的图,那肯定是最右面的 f_3(x) 的经验风险函数最小了,因为它对历史的数据拟合的最好嘛。但是我们从图上来看 f_3(x)肯定不是最好的,因为它过度学习历史数据,导致它在真正预测时效果会很不好,这种情况称为过拟合(over-fitting)。

    为什么会造成这种结果?大白话说就是它的函数太复杂了,都有四次方了,这就引出了下面的概念,我们不仅要让经验风险最小化,还要让结构风险最小化。这个时候就定义了一个函数 J(f) ,这个函数专门用来度量模型的复杂度,在机器学习中也叫正则化(regularization)。常用的有 L_1 , L_2 范数。

    到这一步我们就可以说我们最终的优化函数是:min\frac{1}{N}\sum_{i=1}^{N}L(y_{i},f(x_{i}))+\lambda J(f) ,即最优化经验风险和结构风险,而这个函数就被称为目标函数

    结合上面的例子来分析:最左面的 f_1(x) 结构风险最小(模型结构最简单),但是经验风险最大(对历史数据拟合的最差);最右面的 f_3(x) 经验风险最小(对历史数据拟合的最好),但是结构风险最大(模型结构最复杂);而 f_2(x) 达到了二者的良好平衡,最适合用来预测未知数据集。

    展开全文
  • (C语言)常见字符函数和字符串函数

    万次阅读 多人点赞 2018-07-23 10:49:50
    我们都知道,在C语言里有string.h这个头文件,但是C语言里没有string这个类型。 字符串通常放在常量字符串中或者字符数组中,字符串常量适用于那些对她不做修改的字符串函数。 string.h这个头文件里声明的函数原型...

    我们都知道,在C语言里有string.h这个头文件,但是C语言里没有string这个类型。
    字符串通常放在常量字符串中或者字符数组中,字符串常量适用于那些对她不做修改的字符串函数。
    string.h这个头文件里声明的函数原型也全是针对char数组的种种操作。
    直到C++中才出现了string这个类

    这篇文章就简单整理一下C语言中处理字符、字符串的库函数。

    strlen

     size_t  strlen( const char*  str)

    功能:计算字符串长度,不包含’\0’
    返回值:返回字符串的字符数
    说明:

    • strlen() 函数计算的是字符串的实际长度,遇到第一个’\0’结束;
    • 参数指向的字符串必须以 ’ \0 ‘结束
    • 函数返回值一定是size_t ,是无符号的
    • 如果你只定义没有给它赋初值,这个结果是不定的,它会从首地址一直找下去,直到遇到’\0’停止
    • sizeof返回的是变量声明后所占的内存数,不是实际长度,此外sizeof不是函数,仅仅是一个操作符,strlen()是函数

    strcpy

    char* strcpy(char* dest,char* src)

    功 能: 将参数src字符串拷贝至参数dest所指的地址
    返回值: 返回参数dest的字符串起始地址
    说明:

    • 源字符串必须以’\0’结束
    • 会将源字符串的’\0’拷贝到目标空间
    • 目标空间必须可变
    • 如果参数dest所指的内存空间不够大,可能会造成缓冲溢出的错误情况,在编写程序时需特别留意,或者用strncpy()来取代

    strncpy

    char* strncpy(char* dest,const char* src,size_t num)

    功能:拷贝src字符串的前num个字符至dest
    返回值:dest字符串起始地址
    说明:

    • 如果src字符串长度小于num,则拷贝完字符串后,在目标后追加0,直到num个
    • strncpy不会向dest追加’\0’
    • src和dest所指的内存区域不能重叠,且dest必须有足够的空间放置n个字符

    strcat

    char* strcat(char* dest,const char* src)

    功能: 字符串拼接
    返回值:返回dest字符串起始地址
    说明:

    - 源字符串必须’\0’结束
    - 目标空间必须可修改
    - strcat() 会将参数src字符串复制到参数dest所指的字符串尾部
    - dest最后的结束字符’\0’会被覆盖掉,并在连接后的字符串的尾部再增加一个’\0’
    - dest与src所指的内存空间不能重叠,且dest要有足够的空间来容纳要复制的字符串

    strncat

    char* strncat (char* dest,const char* src,size_t num)

    功能:将n个字符追加到字符串结尾
    返回值:返回dest字符串的起始地址
    说明:

    • strncat将会从字符串src的开头拷贝n个字符到dest字符串尾部
    • dest要有足够的空间来容纳要拷贝的字符串
    • 如果n大于字符串src的长度,那么仅将src全部追加到dest的尾部
    • strncat会将dest字符串最后的’\0’覆盖掉,字符追加完成后,再追加’\0’

    strcmp

    int strcmp (const char* str1,const char* str2)

    功能:字符串比较
    返回值:若参数s1和s2字符串相同则返回0,s1若大于s2则返回大于0的值,s1若小于s2则返回小于0的值
    说明:

    • 判断两个字符串大小1)ASII码 2)长度
    • 区分大小写比较的,如果希望不区分大小写进行字符串比较,可以使用stricmp函数

    strncmp

    int strncmp(const char* str1,const char* str2,size_t num)

    功能:指定长度比较
    返回值:同strcmp

    strstr

    char* strstr(const char* str,const char* substr)
    功能:检索子串在字符串中首次出现的位置
    返回值:返回字符串str中第一次出现子串substr的地址;如果没有检索到子串,则返回NULL

    strchr

    char* strchr(const char* str,char c)

    功能:查找字符串中第一次出现c的位置
    返回值:返回首次出现c的位置的指针,如果s中不存在c则返回NULL

    strrchr

    char* strchr(const char* str,char c)

    功能:查找字符串中最后一次出现c的位置
    返回值:返回最后一次出现c的位置的指针,如果s中不存在c则返回NULL

    strspn

    size_t  strspn(const char* str1, const char* str2)
    

    功能:用来计算str1字符串开始部分匹配str2字符串的字符个数
    返回值:返回字符串str1开头连续包含字符串str2内的字符数目。

    • 如果str所包含的字符都属于str2,那么返回str1的长度
    • 如果str的第一个字符不属于str2,那么返回0

    strcspn

    size_t  strspn(const char* str1, const char* str2)

    功能:用来计算str1字符串开始部分不匹配str2字符串的字符个数
    返回值:返回字符串str1开头部分不出现在字符串str2内的字符数目。

    strtok

    char* strtok(char* str,const char* sep)

    功能:根据分隔符将字符串分隔成一个个片段
    返回值:返回下一个分割后的字符串指针,如果已无从分割则返回NULL
    说明:
    - sep参数是个字符串,定义了用作分隔符的字符集合
    - 第一个参数指定一个字符串,它包含了一个或者多个由sqp字符串中一个或者多个字符分割的标记
    - 第一次调用时将字符串首地址传进去,之后调用不用传地址,内部会有static函数保存指向地址
    - 分隔符不作为输出内容,只做分界符
    - 当strtok在参数s的字符串中发现到参数sep的分割字符时则会将该字符改为’\0’字符
    - 在第一次调用时,strtok必须赋予参数str字符串,往后的调用则将参数s设置成NULL
    - strtok会修改原字符串,所以必须放至栈上

    strerror

    char* strerror(int errnum)
    

    功能:返回指向错误信息字符串的指针
    说明:

    • 必须包含头文件errno.h

    strpbrk

    char* strpbrk(const char*  str1, const char* str2)

    功能:在字符串s1中寻找字符串s2中任何一个字符相匹配的第一个字符的位置,空字符NULL不包括在内

    atoi

    int atoi(const char* str)

    功能:将字符串转换成整型
    返回值:返回转换后的整型数。如果str不能转换成int或者str为空字符串,那么将返回0
    说明:

    • ANSI C规范定义了 stof()、atoi()、atol()、strtod()、strtol()、strtoul()共6个可以将字符串转换为数字的函数,可以对比学习
    • 另外在C99/C++11规范中又新增了5个函数,分别是atoll()、strtof()、strtold()、strtoll()、strtoull()

    字符分类函数:

    int isalnum(int c):检查字符是否为数字或字母;(0~9,a~z,A~Z) 
    int isalpha(int c):检查字符是否为字母;(a~z, A~Z) 
    int iscntrl(int c):检查字符是否为控制字符;(八进制000~037以及177的字符) 
    int isdigit(int c):检查字符是否为十进制数字;(0~9) 
    int isgraph(int c):检查字符是否为图形表示,依赖于使用语言的环境;0~9,a~z,A~Z,以及标点符号) 
    int islower(int c):检查字符是否为小写的字母;(a~z) 
    int isprint(int c):检查字符是否为可打印的;(数字、字母、标点符号、空白字符) 
    int ispunct(int c):检查字符是否为标点符号;(! ” # $ % & ’ ( ) * + , - . / : ; < = > ? @ [ ] ^ _ ` { | } ~等) 
    int isspace(int c):检查字符是否为空白字符;(TAB、换行、垂直TAB、换页、回车、空格) 
    int isupper(int c):检查字符是否为大写字母;(A~Z) 
    int isxdigit(int c):检查字符是否为十六进制数字;(0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f) 

    字符转换

    int tolower(int c):转化字符为小写字母; 
    int toupper(int c):转化字符为大写字母;
    展开全文
  • 回归模型常见的损失函数

    万次阅读 2019-05-21 01:17:44
    机器学习中的所有算法都依赖于最小化或最大化函数,我们将其称为“目标函数”。最小化的函数组称为“损失函数”。损失函数是衡量预测模型在能够预测预期结果方面的表现有多好的指标。寻找最小值的最常用方法是“梯度...

    注意:如果图片不显示,请建议科学上网或者使用VPN。
    机器学习中的所有算法都依赖于最小化或最大化函数,我们将其称为“目标函数”。最小化的函数组称为“损失函数”。损失函数是衡量预测模型在能够预测预期结果方面的表现有多好的指标。寻找最小值的最常用方法是“梯度下降”。想想这个函数的作用,如起伏的山脉和梯度下降就像滑下山到达最低点。

    没有一种损失函数适用于所有类型的数据。它取决于许多因素,包括异常值的存在,机器学习算法的选择,梯度下降的时间效率,易于找到衍生物和预测的置信度。

    损失函数可大致分为两类:分类和回归损失。在这篇文章中,专注于讨论回归损失函数。

    在这里插入图片描述

    回归损失

    1.均方误差

    均方误差(MSE)(又称二次损失,L2损失)是最常用的回归损失函数。MSE是目标变量和预测值之间的平方距离之和。
    M S E = ∑ i = 1 n ( y i − y i p ) 2 n M S E=\frac{\sum_{i=1}^{n}\left(y_{i}-y_{i}^{p}\right)^{2}}{n} MSE=ni=1n(yiyip)2
    下面是MSE函数的图,其中真实目标值为100,预测值范围在-10,000到10,000之间。MSE损失(Y轴)在预测(X轴)= 100时达到其最小值。其范围是0到∞。

    img

    ​ MSE损失(Y轴)与预测(X轴)的关系图

    2. 平均绝对误差

    平均绝对误差(MAE)(又称L1损失)是用于回归模型的另一种损失函数。MAE是我们的目标和预测变量之间的绝对差异的总和。因此,它在不考虑方向的情况下测量一组预测中的平均误差大小。(如果我们也考虑方向,那将被称为平均偏差误差(MBE),它是残差/误差的总和)。其范围也是0到∞。
    M A E = ∑ i = 1 n ∣ y i − y i p ∣ n M A E=\frac{\sum_{i=1}^{n}\left|y_{i}-y_{i}^{p}\right|}{n} MAE=ni=1nyiyip
    img

    ​ MAE损失(Y轴)与预测(X轴)的关系图

    MSE与MAE(L2损失与L1损失)

    简而言之, 使用平方误差更容易解决,但使用绝对误差对异常值更为稳健。但是让我们明白为什么!

    每当我们训练机器学习模型时,我们的目标是找到最小化损失函数的点。当然,当预测完全等于真实值时,两个函数都达到最小值。

    这里是两个python代码的快速回顾。

    import numpy as np
    
    #true:真实目标变量的数组
    #prep:预测数组
    
    def mse(true,pred): 
        return np.sum((true  -  pred)** 2def mae(true,pred):
    	return np.sum(np.abs(true  -  pred))
    

    让我们看看MAE和均方根误差的值(RMSE,它只是MSE的平方根,使其与MAE的比例相同)。在第一种情况下,预测接近真实值,并且误差在观察值之间具有小的差异。在第二个,有一个异常值观察,误差很高。

    img

    我们从中观察到了什么,它如何帮助我们选择使用哪种损失函数?

    由于MSE平方误差(y-y_predicted = e),如果e> 1,则误差(e)的值会增加很多。如果我们的数据中有异常值,则e的值将为高,e²将为>> | E |。这将使具有MSE损失的模型比具有MAE损失的模型对异常值更敏感。在上面的第二种情况中,将调整RMSE作为损失的模型,以便以牺牲其他常见示例为代价来最小化单个异常情况,这将降低其整体性能。

    如果训练数据被异常值破坏(即我们在训练环境中存在错误较大的正值或负值,而不是我们的测试环境),则MAE损失很有用

    直观地说,我们可以考虑一下这样的:如果我们只给一个预测为所有尽量减少MSE的意见,那么预测应该是所有目标值的均值。但是,如果我们试图最小化MAE,那么预测将是所有观测的中位数。我们知道,中值对异常值的影响比均值更强,因此使用MAE对异常值处理效果要比MSE更好。

    使用MAE损失(尤其是神经网络)的一个大问题是它的梯度始终是相同的,这意味着即使对于小的损耗值,梯度也会很大。这对学习不利。为了解决这个问题,我们可以使用随着我们接近最小值而降低的动态学习率。在这种情况下,MSE表现良好,即使具有固定的学习速率也会收敛。MSE损失的梯度对于较大的损失值是高的,并且随着损失接近0而降低,使其在训练结束时更精确(见下图)。

    img

    决定使用哪种损失函数如果异常值表示对业务很重要且应该检测到的异常,那么我们应该使用MSE。另一方面,如果我们认为异常值只表示损坏的数据,那么我们应该选择MAE作为损失。

    我建议阅读这篇文章,并进行一项很好的研究,比较在有异常值存在和不存在的情况下使用L1损失和L2损失的回归模型的性能。请记住,L1和L2损失只是MAE和MSE的另一个名称。

    L1损失对异常值更为稳健,但其衍生物不连续,使得找到解决方案效率低下。L2损失对异常值敏感,但提供更稳定和封闭的形式解决方案(通过将其导数设置为0)。

    **两者都有问题:**可能存在损失函数都没有给出理想预测的情况。例如,如果我们数据中90%的观察值具有150的真实目标值,则剩余的10%具有0-30之间的目标值。然后,MAE作为损失的模型可能预测所有观察值为150,忽略10%的离群值情况,因为它将试图达到中值。在相同的情况下,使用MSE的模型会给出0到30范围内的许多预测,因为它会偏向异常值。

    **在这种情况下该怎么办?**一个简单的解决方法是转换目标变量。另一种方法是尝试不同的损失功能。这是我们的第三次亏损功能背后的动机,Huber损失。

    3. Huber损失

    Huber损失(又称平滑平均绝对误差)对数据中的异常值的敏感性低于平方误差损失。它在0处也是可微分的。它基本上是绝对误差,当误差很小时变为二次曲线。该误差必须多小才能使其成为二次方取决于可以调整的超参数δ(delta)。当δ0时,**Huber损失接近**MAE,当δ∞(大数)时, Huber损耗接近MSE。
    L δ ( y , f ( x ) ) = { 1 2 ( y − f ( x ) ) 2  for  ∣ y − f ( x ) ∣ ≤ δ δ ∣ y − f ( x ) ∣ − 1 2 δ 2  otherwise  L_{\delta}(y, f(x))=\left\{\begin{array}{ll}{\frac{1}{2}(y-f(x))^{2}} &amp; {\text { for }|y-f(x)| \leq \delta} \\ {\delta|y-f(x)|-\frac{1}{2} \delta^{2}} &amp; {\text { otherwise }}\end{array}\right. Lδ(y,f(x))={21(yf(x))2δyf(x)21δ2 for yf(x)δ otherwise 
    img
    Hoss损失(Y轴)与预测(X轴)的关系图。

    δ的选择至关重要,因为它决定了你愿意考虑的异常值。大于δ的残差最小化为L1(对大异常值不敏感),而小于δ的残差最小化为“适当”L2。

    **为什么要使用Huber Loss?**使用MAE训练神经网络的一个大问题是其持续的大梯度,这可能导致在训练结束时使用梯度下降丢失最小值。对于MSE,随着损失接近其最小值,梯度减小,使其更精确。

    在这种情况下,胡贝尔损失确实很有用,因为它在最小值附近弯曲,从而降低了梯度。而且它比MSE更强大。因此,它结合了MSE和MAE的良好特性。然而,Huber损失问题是我们可能需要训练超参数δ,这是一个迭代过程。

    4. Log-Cosh损失

    Log-cosh是回归任务中使用的另一个函数,比L2更平滑。Log-cosh是预测误差的双曲余弦的对数。
    L ( y , y p ) = ∑ i = 1 n log ⁡ ( cosh ⁡ ( y i p − y i ) ) L\left(y, y^{p}\right)=\sum_{i=1}^{n} \log \left(\cosh \left(y_{i}^{p}-y_{i}\right)\right) L(y,yp)=i=1nlog(cosh(yipyi))
    img
    Log-cosh Loss(Y轴)与预测(X轴)的关系图。

    **优点:**当x值较小 时,log(cosh(x))约等于(x ** 2) / 2;当x值较大时,约等于abs(x) - log(2)。这意味着’logcosh’的作用大部分类似于均方误差,但不会受到偶然误差预测的强烈影响。它具有Huber损失的所有优点,并且它在各处都是可区分的,与Huber损失不同。

    **为什么我们需要二阶导数?**像XGBoost这样的许多ML模型实现使用牛顿方法来找到最优,这就是为什么需要二阶导数(Hessian)。对于像XGBoost这样的ML框架,两个可区分的函数更有利。

    img

    XgBoost中使用的目标函数。注意对1阶和2阶导数的依赖性

    但Log-cosh损失并不完美。对于非常大的脱靶预测是恒定的,它仍然存在梯度和粗麻布的问题,因此导致没有XGBoost的分裂。

    Huber和Log-cosh损失函数的Python代码:

    # huber loss
    def huber(true, pred, delta):
        loss = np.where(np.abs(true-pred) < delta , 0.5*((true-pred)**2), delta*np.abs(true - pred) - 0.5*(delta**2))
        return np.sum(loss)
    
    # log cosh loss
    def logcosh(true, pred):
        loss = np.log(np.cosh(pred - true))
        return np.sum(loss)
    
    5.分位数损失

    在大多数现实世界预测问题中,我们通常有兴趣了解预测中的不确定性。了解预测范围而不仅仅是点估计可以显着改善许多业务问题的决策过程。

    当我们对预测区间而不是仅预测点预测感兴趣时,分位数损失函数变得有用。来自最小二乘回归的预测区间基于以下假设:残差在独立变量的值上具有恒定的方差。我们认为违反这一假设的线性回归模型。我们也不能仅仅通过使用非线性函数或基于树的模型来更好地建模。这种情况来将不能利用线性回归模型来拟合。这是分位数损失和分位数回归将派上用场了,因为基于分位数损失的回归甚至对于具有非恒定方差或非正态分布的残差提供了合理的预测区间。

    让我们看一个工作示例,以更好地理解为什么基于分位数损失的回归在异方差数据中表现良好。

    分位数回归与普通最小二乘回归

    img

    ​ 左:具有恒定的残差方差。右:Y的方差随X2增加。

    img

    ​ 橙色线表示两种情况的OLS估计值

    img

    分位数回归。虚线表示基于回归的0.05和0.95分位数损失函数

    了解分位数损失函数

    基于分位数的回归旨在估计给定某些预测变量值的响应变量的条件“分位数”。分位数损失实际上只是MAE的延伸(当分位数为50%时,它是MAE)。

    我们的想法是根据我们是否希望为正误差或负误差提供更多价值来选择分位数值。损失函数试图基于所选分位数( γ \gamma γ)的值给予过高估计和低估的不同惩罚。例如, γ \gamma γ= 0.25的分位数损失函数给予过高估计更多的惩罚,并试图将预测值保持在中位数以下
    L γ ( y , y p ) = ∑ i = y i &lt; y i p ( γ − 1 ) . ∣ y i − y i p ∣ + ∑ i = y i ≥ y i p ( γ ) . ∣ y i − y i p ∣ L_{\gamma}\left(y, y^{p}\right)=\sum_{i=y_{i}&lt;y_{i}^{p}}(\gamma-1) .\left|y_{i}-y_{i}^{p}\right|+\sum_{i=y_{i} \geq y_{i}^{p}}(\gamma) .\left|y_{i}-y_{i}^{p}\right| Lγ(y,yp)=i=yi<yip(γ1).yiyip+i=yiyip(γ).yiyip
    γ \gamma γ是所需的分位数,其值介于0和1之间。

    img

    分位数损失(Y轴)与预测(X轴)的关系图。Y = 0的真值

    我们还可以使用此损失函数来计算神经网络或基于树的模型中的预测间隔。下面是梯度提升树回归器的Sklearn实现示例。

    img

    使用分位数损失预测区间(梯度增强回归)http://scikit-learn.org/stable/auto_examples/ensemble/plot_gradient_boosting_quantile.html*

    上图显示了使用sklearn库的GradientBoostingRegression中可用的分位数损失函数计算的90%预测区间。上限构建为 γ \gamma γ= 0.95,下限使用 γ \gamma γ= 0.05。

    比较研究:

    Gradient boosting machines,a tutorial ”中提供了一个很好的比较模拟。为了证明上述所有损失函数的性质,他们模拟了一个采用sinc(x函数采样的数据集,该函数具有两个人工模拟噪声源:高斯噪声分量ε~ N(0,σ2)和脉冲噪声分量ξ~Bern(p)。添加脉冲噪声项以说明鲁棒性效应。以下是使用不同损失函数拟合GBM回归量的结果。

    img

    连续损失函数:(A)MSE损失函数; (B)MAE损失函数; (C)Huber损失函数; (D)分位数损失函数
    演示将平滑的GBM拟合到有噪声的sinc(x)数据
    (E)原始sinc(x)函数; (F)MSE和MAE损失的光滑GBM; (Huber损失的光滑GBM,δ= {4,2,1}; (H)分位数损失的光滑GBM,α= {0.5,0.1,0.9}。

    模拟的一些观察结果:

    • 具有MAE损失函数的模型的预测受脉冲噪声的影响较小,而具有MSE损失函数的预测由于引起的偏差而略微偏差。
    • 对于具有huber损失函数的模型,预测对于选择的超参数值非常敏感。
    • 分位数损失函数可以很好地估计相应的置信水平。

    单个图中的所有损失函数。

    img

    翻译文献:

    https://heartbeat.fritz.ai/5-regression-loss-functions-all-machine-learners-should-know-4fb140e9d4b0

    展开全文
  • 机器学习中常见的损失函数

    万次阅读 多人点赞 2016-09-07 19:16:56
    机器学习中常见的损失函数   一般来说,我们在进行机器学习任务时,使用的每一个算法都有一个目标函数,算法便是对这个目标函数进行优化,特别是在分类或者回归任务中,便是使用损失函数(Loss Function)作为其...
  • PHP代码审计-常见危险函数

    千次阅读 2017-09-20 15:53:17
    包含函数:require、include、require_once、include_once 命令执行函数:exec、system、passthru、proc_open、shell_exec、system 文件操作函数:file、copy、file_get_contents、file_put_contents、fopen等 特殊...
  • JavaScript常见变量和函数命名示例

    万次阅读 2020-07-21 15:16:17
    JavaScript作为前端开发从业人员必须...通过按JavaScript的数据类型分类着手、细到一个函数的参数命名,并提供众多可选方案,并尽量给出其适用范围和利弊。 JavaScript常见变量和函数命名示例思维导图 需要注意的是由
  • 1. 机器学习中常见的损失函数  一般来说,我们在进行机器学习任务时,使用的每一个算法都有一个目标函数,算法便是对这个目标函数进行优化,特别是在分类或者回归任务中,便是使用损失函数(Loss Function)作为其...
  • 常见的hash函数算法

    千次阅读 2014-02-21 16:06:57
    散列表,它是基于快速存取的角度设计的,也是一种典型的“空间换时间”的做法。顾名思义,该数据结构可以理解为一个线性表,但是其中的元素不是紧密排列的,...这个映射函数叫做散列函数,存放记录的数组叫做散列表。
  • 常见软件测试类型分类

    万次阅读 2018-09-20 09:48:05
    软件测试类型 1)回归测试 回归测试: (regression testing): 回归测试有两类:用例回归和错误回归;用例回归是过一段时间以后再回头对以前使用过的用例在重新进行测试,看看会重新发现问题。错误回归,就是在新...
  • 作者:章华燕编辑:赵一帆1、机器学习中常见的损失函数一般来说,我们在进行机器学习任务时,使用的每一个算法都有一个目标函数,算法便是对这个目标函数进行优化,特别是在分类或者回归任务中,便是使用损失函数...
  • 深度学习中常见的损失函数

    千次阅读 2020-04-28 11:00:00
    文章来源于AI的那些事儿,作者黄鸿波2018年我出版了《TensorFlow进阶指南 基础、算法与应用》这本书,今天我把这本书中关于常见的损失函数这一节的内容公开出来,希望能对大家有所帮...
  • 机器学习之常见的损失函数(loss function)

    万次阅读 多人点赞 2019-03-06 09:40:43
    解决一个机器学习问题主要有两部分:数据和算法。...所以仅在此以自己理解的方式总结一些常见的损失函数,作为笔记方便日后复习。 参考文章: 一、总览 在机器学习中,通常把模型关于单个样本预测值与真实值的差...
  • 在机器学习中,对于目标函数、损失函数、代价函数等不同书上有不同的定义。通常来讲,目标函数可以衡量一个模型的好坏,对于模型的优化通常求解模型的最大化或者最小化,当求取最小化时也称loss function即损失函数...
  • 深度学习中常见的loss函数汇总

    千次阅读 2020-05-19 21:22:18
      机器学习任务中的损失函数可以大体分为两种类型:回归损失和分类损失。在此基础上,在深度学习任务中又发展了很多不同的损失函数,由于在网络训练过程中损失函数指导着网络的学习,因此选择合适的损失函数也很重
  • 常见的网络攻击类型

    万次阅读 2019-02-20 12:23:46
    常见的网络攻击类型 一、拒绝服务攻击 1.拒绝服务攻击 Dos(Denial of Service)是一种利用合理的服务请求占用过多的服务资源,从而使合法用户无法得到服务响应的网络攻击行为。 被DOS攻击时的现象大致有: 被...
  • C++常见的字符串处理函数

    千次阅读 多人点赞 2019-06-21 21:13:40
    C++常见的字符串处理函数 #include< string > 1. 应用于查找的find()函数
  • 机器学习中常见的几种损失函数

    千次阅读 2018-05-10 13:38:10
    在分类或者回归问题中,通常使用损失函数(代价函数)作为其目标函数。损失函数用来评价模型的预测值和真实值不一样的程度,损失函数越好,通常模型的性能越好。不同的算法使用的损失函数不一样。 损失函数分为...
  • 常见的损失函数(loss function)总结

    千次阅读 2021-01-15 11:40:00
    作者丨yyHaker@知乎来源丨https://zhuanlan.zhihu.com/p/58883095编辑丨极市平台导读本文总结了常见的八种损失函数的优缺点,包括:0-1损失函数、...
  • 问题描述:在C语言标准所提供的库函数中,有关于三个常见的关于内存操作的函数:memcpy(内存拷贝),memmove(内存移动,亦可实现内存拷贝)和memset(内存块数据的初始化)。memcpy函数存在局限性,因为其移动拷贝...
  • Windows编程 Win32API中常见的数据类型

    千次阅读 2015-12-31 15:20:28
    Win32API有一套和C\C++基本数据类型不同的数据类型. C\C++语言的数据类型有如下几个缺陷: 数据类型平台相关,在不同平台上,同一个数据类型可能占用不同的空间大小。典型的,在16位系统上,int类型和short int...
  • CV之OpenCV:OpenCV库涉及概念、常见函数、常用案例、HALCON软件简介之详细攻略 目录 CV入门 OpenCV使用过程 1、基本教程 OpenCV的相关概念 1、基本概念 OpenCV一些常用函数 OpenCV一些常用案例 1、...
  • CUDA常见函数(一)(小白入门)

    千次阅读 2020-01-23 22:47:48
    主要是在图像处理时用到的一些函数,在这里汇总一下。
  • snprintf函数常见功能

    千次阅读 2014-04-22 20:04:37
    //a表示目标字符串,sizeof(a)是转换的字符数,“%d”待转类型,j待转整型常量。 cout ; } 输出结果为:12 2、浮点型转换为字符串。 #include #include #include using ...
  • python3 open函数常见问题

    千次阅读 2018-10-27 00:24:36
    open函数,该函数用于文件处理 操作文件时,一般需要经历如下步骤: 打开文件 操作文件 一、打开文件 1 文件句柄=open('文件路径','模式') 打开文件时,需要指定文件路径和以何等方式打开...
  • 使用socket函数的一些常见错误

    万次阅读 2015-08-20 14:45:36
    原文地址:使用socket函数的一些常见错误1.socketSOCKET socket( int af, int type, int protocol ); af:常为AF_INET 使用AF_ISO等其他地址族标识,而非AF_INET。 返回:-1。 错误:10047(使用了与请求的协议不...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 204,163
精华内容 81,665
关键字:

常见的目标函数的类型