文章目录
问题：
解答
1.算术运算
2.关系运算

问题：
今天遇到一个有趣的问题

…

if（Rear->link&&Rear->link->expon>e）

…

使用使用关系运算符判断指针是否为空。
解答
是不是对指针的任何运算都是合法的呢？答案是它可以执行某些运算，但并非所有的运算都合法。除了加法运算之外，你还可以对指针执行一些其他运算，但并不是很多。

指针加上一个整数的结果是另一个指针。问题是，它指向哪里？如果你将一个字符指针加1，运算结果产生的指针指向内存中的下一个字符。float占据的内存空间不止1个字节，如果你将一个指向float的指针加1，将会发生什么？它会不会指向该float值内部的某个字节呢？

答案是否定的。当一个指针和一个整数量进行算术运算时，整数在执行加法运算前始终会根据合适的大小进行调整。这个“合适的大小”就是指针所指向类型的大小，“调整”就是把整数值和“合适的大小”相乘。为了更好的说明，试想在某台机器上，float占据4个字节。在计算float型指针加3的表达式时候，这个3将根据float类型的大小（此例中为4）进行调整（相乘），这样实际上加到指针上的整型值为12。

把3与指针相加使指针的值增加3个float的大小，而不是3个字节。这个行为较之获得一个指向一个float值内部某个位置的指针更为合理。下表包含了一些加法运算的例子。调整的美感在于指针算法并不依赖于指针的类型。换句话说，如果p是个指向float的指针，那么p+1就指向下一个float，其他类型也是如此。



1.算术运算

C的指针的算术运算只局限于两种形式。第一种形式是：    指针±整数  标准定义这种形式只能用于指向数组中某个元素的指针，如图所示：



并且这类表达式的结果类型也是指针。这种形式也适用于使用malloc函数动态分配获得的内存。
对一个指针加1使它指向数组中的下一个元素，加5使它向右移动5个元素的位置，依次类推。把一个指针减去3使它向左移动3个元素的位置。
第二种类型的指针运算具有如下的形式：   指针—指针
只有当两个指针都指向同一个数组中的元素时，才允许从一个指针减去另一个指针，如下所示：



两个指针相减的结果的类型是ptrdiff_t，它是一种有符号整数类型。减法运算的值是两个指针在内存中的距离（以数组元素的长度为单位，而不是以字节为单位），因为减法运算的结果将除以数组元素类型的长度。



**如果两个指针所指向的不是同一个数组中的元素，那么它们之间相减的结果是未定义的。**程序员无从知道两个数组在内存中的相对位置，如果不知道这一点，两个指针之间的距离就毫无意义。
2.关系运算
关系运算：< <= > >=  不过前提是它们都指向同一个数组中的元素。根据你所使用的操作符，比较表达式将告诉你哪个指针指向数组中更前或更后的元素。标准并未定义如果两个任意的指针进行比较会产生什么结果。

逻辑回归的定义
简单来说，  逻辑回归（Logistic Regression）是一种用于解决二分类（0 or 1）问题的机器学习方法，用于估计某种事物的可能性。比如某用户购买某商品的可能性，某病人患有某种疾病的可能性，以及某广告被用户点击的可能性等。 注意，这里用的是“可能性”，而非数学上的“概率”，logisitc回归的结果并非数学定义中的概率值，不可以直接当做概率值来用。该结果往往用于和其他特征值加权求和，而非直接相乘。
那么逻辑回归与线性回归是什么关系呢？ 
逻辑回归（Logistic Regression）与线性回归（Linear Regression）都是一种广义线性模型（generalized linear model）。逻辑回归假设因变量 y 服从伯努利分布，而线性回归假设因变量 y 服从高斯分布。 因此与线性回归有很多相同之处，去除Sigmoid映射函数的话，逻辑回归算法就是一个线性回归。可以说，逻辑回归是以线性回归为理论支持的，但是逻辑回归通过Sigmoid函数引入了非线性因素，因此可以轻松处理0/1分类问题。   
假设函数（Hypothesis function）
首先我们要先介绍一下Sigmoid函数，也称为逻辑函数（Logistic function）：
其函数曲线如下：


从上图可以看到sigmoid函数是一个s形的曲线，它的取值在[0, 1]之间，在远离0的地方函数的值会很快接近0或者1。它的这个特性对于解决二分类问题十分重要
逻辑回归的假设函数形式如下： 
所以：
其中  是我们的输入，  为我们要求取的参数。    
一个机器学习的模型，实际上是把决策函数限定在某一组条件下，这组限定条件就决定了模型的假设空间。当然，我们还希望这组限定条件简单而合理。而逻辑回归模型所做的假设是：
这个函数的意思就是在给定  和  的条件下  的概率。
这里  就是我们上面提到的sigmoid函数，与之相对应的决策函数为：
选择0.5作为阈值是一个一般的做法，实际应用时特定的情况可以选择不同阈值，如果对正例的判别准确性要求高，可以选择阈值大一些，对正例的召回要求高，则可以选择阈值小一些。
决策边界（Decision Boundary）
决策边界，也称为决策面，是用于在N维空间，将不同类别样本分开的平面或曲面。
注意：决策边界是假设函数的属性，由参数决定，而不是由数据集的特征决定。
这里我们引用Andrew Ng 课程上的两张图来解释这个问题：
线性决策边界


这里决策边界为: 
非线性决策边界：

这里决策边界为: 
上面两张图很清晰的解释了什么是决策边界，决策边界其实就是一个方程，在逻辑回归中，决策边界由  定义。
这里我们要注意理解一下假设函数和决策边界函数的区别与联系。决策边界是假设函数的属性，由假设函数的参数（  ）决定。
在逻辑回归中，假设函数  用于计算样本属于某类别的可能性；决策函数  用于计算（给出）样本的类别；决策边界  是一个方程，用于标识出分类函数（模型）的分类边界。 
代价函数（Cost Function）
什么是代价函数？
假设有训练样本  ，模型为  , 参数为  。  （  表示  的转置）。
<1>. 概况来讲，任何能够衡量模型预测出来的值  与真实值  之间的差异的函数都可以叫做代价函数  ，如果有多个样本，则可以将所有代价函数的取值求均值，记做  。因此很容易就可以得出以下关于代价函数的性质：
选择代价函数时，最好挑选对参数  可微的函数（全微分存在，偏导数一定存在）
对于每种算法来说，代价函数不是唯一的；
代价函数是参数  的函数；
总的代价函数  可以用来评价模型的好坏，代价函数越小说明模型和参数越符合训练样本  ；
 是一个标量；
<2>. 当我们确定了模型  ，后面做的所有事情就是训练模型的参数  。那么什么时候模型的训练才能结束呢？这时候也涉及到代价函数，由于代价函数是用来衡量模型好坏的，我们的目标当然是得到最好的模型（也就是最符合训练样本的模型）。因此训练参数的过程就是不断改变  ，从而得到更小的  的过程。理想情况下，当我们取到代价函数J的最小值时，就得到了最优的参数  ，记为：
例如，  ，表示我们的模型完美的拟合了观察的数据，没有任何误差。
<3>. 在优化参数θ的过程中，最常用的方法是梯度下降，这里的梯度就是代价函数  对  的偏导数。由于需要求偏导，我们可以得到另一个关于代价函数的性质：
选择代价函数时，最好挑选对参数  可微的函数（全微分存在，偏导数一定存在）
代价函数的常见形式
经过上面的描述，一个好的代价函数需要满足两个最基本的要求：能够评价模型的准确性，对参数  可微。 
<1>. 在线性回归中，最常用的是均方误差(Mean squared error)，即
 ：训练样本的个数；
 ：用参数  和  预测出来的y值；
 ：原训练样本中的  值，也就是标准答案;
上角标  ：第  个样本。
<2>. 在逻辑回归中，最常用的是代价函数是交叉熵(Cross Entropy)，交叉熵是一个常见的代价函数，在神经网络中也会用到。下面是《神经网络与深度学习》一书对交叉熵的解释：
交叉熵是对「出乎意料」（译者注：原文使用suprise）的度量。神经元的目标是去计算函数x→y=y(x)。但是我们让它取而代之计算函数x→a=a(x)。假设我们把a当作y等于1的概率，1−a是y等于0的概率。那么，交叉熵衡量的是我们在知道y的真实值时的平均「出乎意料」程度。当输出是我们期望的值，我们的「出乎意料」程度比较低；当输出不是我们期望的，我们的「出乎意料」程度就比较高。
在1948年，克劳德·艾尔伍德·香农将热力学的熵，引入到信息论，因此它又被称为香农熵(Shannon Entropy)，它是香农信息量(Shannon Information Content, SIC)的期望。香农信息量用来度量不确定性的大小：一个事件的香农信息量等于0，表示该事件的发生不会给我们提供任何新的信息，例如确定性的事件，发生的概率是1，发生了也不会引起任何惊讶；当不可能事件发生时，香农信息量为无穷大，这表示给我们提供了无穷多的新信息，并且使我们无限的惊讶。更多解释可以看这里。
符号说明同上 
但是我们会疑问，为什么这么定义代价函数呢？下面我会简单的解释一下：
PS:由于文章里的公式太多，编辑的时候开始卡顿，这篇就先写到这里，接下来的内容见：
逻辑回归（Logistic Regression）（二）
Reference:
[机器学习] Coursera ML笔记 - 逻辑回归（Logistic Regression）
sigmoid函数详解_mmmmmm_新浪博客
逻辑斯谛回归之决策边界 logistic regression -- decision boundary
【机器学习】代价函数（cost function）

孟岩的《请列提纲》一文说到了大家现在的一种通病。本来要在他的文章下面发表评论，不料验证码老是出问题，只好写在这里了。

其实逻辑性不强并非理工科的专利，据我的观察，理工科学生因为证明啊、做题啊的必须讲究逻辑的关系，这方面反而强于文科学生。

你们有时间去看看文科同学们的文章，听听文科同学们的讲话，就会知道了。

问题实际出在我们的教育本身，你们谁系统学过逻辑吗？我还是当年陪老婆学GRE的时候粗粗地感受了一下什么叫逻辑。然后就发现《新闻联播》等等官方和主流媒体上的各种报道，从逻辑上就是不成立的……

除了写文章，阅读也非常需要这种逻辑，请看国外的技术专家怎样阅读技术图书？。

目录
1、逻辑回归的定义
2、假设函数（Hypothesis function）
3、损失函数（Cost Function）
4、代码实现
4.1 先尝试调用sklearn的线性回归模型训练数据，尝试以下代码，画图查看分类的结果
4.2 用梯度下降法将相同的数据分类，画图和sklearn的结果相比较
4.3 用牛顿法实现结果，画图和sklearn的结果相比较，并比较牛顿法和梯度下降法迭代收敛的次数
4.4 比较梯度下降法和牛顿法收敛速度

1、逻辑回归的定义


主要解决问题：分类问题—二分类问题


如果需要解决多分类问题— softmax 回归


简单来说， 逻辑回归（Logistic Regression）是一种用于解决二分类（0 or 1）问题的机器学习方法，用于估计某种事物的可能性。比如某用户购买某商品的可能性，某病人患有某种疾病的可能性，以及某广告被用户点击的可能性等。 注意，这里用的是“可能性”，而非数学上的“概率”，logisitc回归的结果并非数学定义中的概率值，不可以直接当做概率值来用。该结果往往用于和其他特征值加权求和，而非直接相乘。
那么逻辑回归与线性回归是什么关系呢？
逻辑回归（Logistic Regression）与线性回归（Linear Regression）都是一种广义线性模型（generalized linear model）。逻辑回归假设因变量 y 服从伯努利分布，而线性回归假设因变量 y 服从高斯分布。 因此与线性回归有很多相同之处，去除Sigmoid映射函数的话，逻辑回归算法就是一个线性回归。可以说，逻辑回归是以线性回归为理论支持的，但是逻辑回归通过Sigmoid函数引入了非线性因素，因此可以轻松处理0/1分类问题。
2、假设函数（Hypothesis function）
与线性回归的区别：线性回归预测输出的是$（-∞,+∞）$
而逻辑回归输出的是{0,1}，这里面0我们称之为负例，1称之为正例。
如果分类器用的是回归模型，并且已经训练好了一个模型，可以设置一个阈值：
如果$h_{\theta}(x)≥0.5，$则预测$y=1$，既$y$属于正例
如果$h_{\theta}(x)<0.5，$则预测$y=0$，既$y$属于负例
对于二分类问题来说，线性回归模型的输出值可以大于1也可以小于0，所以我们需要一个函数，将输出转换到0和1之间。这里我们引入一个函数，Sigmoid函数。
首先我们要先介绍一下Sigmoid函数，也称为逻辑函数（Logistic function）：

’
$g(z) = \cfrac{1}{1+e^{-z}}$ 

其函数曲线如下：


从上图可以看到sigmoid函数是一个s形的曲线，它的取值在[0, 1]之间，在远离0的地方函数的值会很快接近0或者1。它的这个特性对于解决二分类问题十分重要
逻辑回归的假设函数形式如下：

$h_{\theta}(x) = g(\theta^Tx),g(z)=\cfrac{1}{1+e^{-z}}$

所以：

$h_{\theta}(x) = \cfrac{1}{1+e^{-(\theta^Tx)}}$
其中 $x$ 是我们的输入， $\theta$ 为我们要求取的参数。
上面式子也可变化为：

’
$\ln\cfrac{h_{\theta}(x)}{1-h_{\theta}(x)} = \theta^Tx$

如果 $h_{\theta}(x)$是样本$x$正例的概率，所以$1-h_{\theta}(x)$是取反例的可能性，两者比值$\cfrac{h_{\theta}(x)}{1-h_{\theta}(x)}$ 称为“几率”（odds），反应了正例的可能性。几率取对数则得到”对数几率“（log odds，亦称logit）

’$\ln\cfrac{h_{\theta}(x)}{1-h_{\theta}(x)}$

我们可以看出上面公式实际上是在用线性回归模型的预测结果去逼近真实标记的对数几率。因此，其对应的模型称为"对数几率回归" 或者”逻辑回归“(logistic regression，亦称logit regression) 。特别需注意到，虽然它的名字是"回归"，但实际却是一种分类学习方法。
3、损失函数（Cost Function）
如何确定$\theta$  , 我们常用的损失函数有均方误差和交叉熵。对于逻辑回归我们选择交叉熵作为损失函数。
给定输入$x$，参数化$\theta$，$y=1$和$y=0$时的概率，数学表达为：

$P(y=1|x;\theta)=h_{\theta}(x)\\
P(y=0|x;\theta)=1-h_{\theta}(x)$

所以

$P(y|x;\theta)=(h_{\theta}(x))^y(1-h_{\theta}(x))^{1-y}$

对应的似然函数为：

$L(\theta) =\prod^{m}_{i=1}P(y^{(i)};\theta)=\prod^{m}_{i=1}(h_{\theta}(x^{(i)}))^{y^{(i)}}(1-h_{\theta}(x^{(i)}))^{1-y^{(i)}}$

给定数据集$\{(x_{i},y_{i})\}^{m}_{i=1}$，逻辑回归模型最大化对数似然函数来估计$\theta$

$l(\theta) =\log L(\theta)=\sum^{m}_{i=1}{y^{(i)}}\log(h_{\theta}(x^{(i)}))+(1-y^{(i)})\log(1-h_{\theta}(x^{(i)}))$
对数似然取最大值等价于损失函数交叉熵取最小值
4、代码实现
4.1 先尝试调用sklearn的线性回归模型训练数据，尝试以下代码，画图查看分类的结果
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

%matplotlib inline

df_X = pd.read_csv('./logistic_x.txt', sep='\ +',header=None, engine='python') #读取X值
ys = pd.read_csv('./logistic_y.txt', sep='\ +',header=None, engine='python') #读取y值
ys = ys.astype(int)
df_X['label'] = ys[0].values #将X按照y值的结果一一打标签


ax = plt.axes()
#在二维图中描绘X点所处位置，直观查看数据点的分布情况
df_X.query('label == 0').plot.scatter(x=0, y=1, ax=ax, color='blue')
df_X.query('label == 1').plot.scatter(x=0, y=1, ax=ax, color='red')

<matplotlib.axes._subplots.AxesSubplot at 0x7f20f7f56e80>


#提取用于学习的数据
Xs = df_X[[0, 1]].values
Xs = np.hstack([np.ones((Xs.shape[0], 1)), Xs]) 
ys = df_X['label'].values

from __future__ import print_function
import numpy as np
from sklearn.linear_model import LogisticRegression

lr = LogisticRegression(fit_intercept=False) #因为前面已经将截距项的值合并到变量中，此处参数设置不需要截距项
lr.fit(Xs, ys) #拟合
score = lr.score(Xs, ys) #结果评价
print("Coefficient: %s" % lr.coef_)
print("Score: %s" % score)


Coefficient: [[-1.70090714  0.55446484  1.07222372]]
Score: 0.898989898989899


/home/xiaoran/anaconda3/lib/python3.6/site-packages/sklearn/linear_model/logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.
  FutureWarning)

ax = plt.axes()

df_X.query('label == 0').plot.scatter(x=0, y=1, ax=ax, color='blue')
df_X.query('label == 1').plot.scatter(x=0, y=1, ax=ax, color='red')

_xs = np.array([np.min(Xs[:,1]), np.max(Xs[:,1])])

#将数据以二维图形式描点，并用学习得出的参数结果作为阈值，划分数据区域
_ys = (lr.coef_[0][0] + lr.coef_[0][1] * _xs) / (- lr.coef_[0][2])
plt.plot(_xs, _ys, lw=1)

[<matplotlib.lines.Line2D at 0x7f20b721da58>]


4.2 用梯度下降法将相同的数据分类，画图和sklearn的结果相比较
class LGR_GD():
    def __init__(self):
        self.w = None 
        self.n_iters = None
    def fit(self,X,y,alpha=0.03,loss = 1e-10): # 设定步长为0.002，判断是否收敛的条件为1e-10
        y = y.reshape(-1,1) #重塑y值的维度以便矩阵运算
        [m,d] = np.shape(X) #自变量的维度
        self.w = np.zeros((1,d)) #将参数的初始值定为0
        tol = 1e5
        self.n_iters = 0
        #============================= show me your code =======================
        while tol > loss: #设置收敛条件
            
            self.n_iters += 1 #更新迭代次数
         #============================= show me your code =======================
    def predict(self, X):
        # 用已经拟合的参数值预测新自变量
        y_pred = X.dot(self.w)
        return y_pred  

if __name__ == "__main__":
    lr_gd = LGR_GD()
    lr_gd.fit(Xs,ys)

    ax = plt.axes()

    df_X.query('label == 0').plot.scatter(x=0, y=1, ax=ax, color='blue')
    df_X.query('label == 1').plot.scatter(x=0, y=1, ax=ax, color='red')

    _xs = np.array([np.min(Xs[:,1]), np.max(Xs[:,1])])
    _ys = (lr_gd.w[0][0] + lr_gd.w[0][1] * _xs) / (- lr_gd.w[0][2])
    plt.plot(_xs, _ys, lw=1)


4.3 用牛顿法实现结果，画图和sklearn的结果相比较，并比较牛顿法和梯度下降法迭代收敛的次数
class LGR_NT():
    def __init__(self):
        self.w = None
        self.n_iters = None
    def fit(self,X,y,loss = 1e-10): # 判断是否收敛的条件为1e-10
        y = y.reshape(-1,1) #重塑y值的维度以便矩阵运算
        [m,d] = np.shape(X) #自变量的维度
        self.w = np.zeros((1,d)) #将参数的初始值定为0
        tol = 1e5
        n_iters =0
        Hessian = np.zeros((d,d))
        #============================= show me your code =======================
        while tol > loss:
            
            n_iters += 1
        #============================= show me your code =======================
        self.w = theta
        self.n_iters = n_iters
        
    def predict(self, X):
        # 用已经拟合的参数值预测新自变量
        y_pred = X.dot(self.w)
        return y_pred  

if __name__ == "__main__":
    lgr_nt = LGR_NT()
    lgr_nt.fit(Xs,ys)

4.4 比较梯度下降法和牛顿法收敛速度
print("梯度下降法结果参数：%s;梯度下降法迭代次数：%s" %(lgr_gd.w,lgr_gd.n_iters))
print("牛顿法结果参数：%s;牛顿法迭代次数：%s" %(lgr_nt.w,lgr_nt.n_iters))

梯度下降法结果参数：[[-2.62051144  0.7603715   1.17194673]];梯度下降法迭代次数：32590
牛顿法结果参数：[[-2.6205116   0.76037154  1.17194674]];牛顿法迭代次数：47

可以，看到，牛顿法的收敛速度比梯度下降法快很多。