实现逻辑回归-神经网络

一、基本概念

1、逻辑回归与线性回归的区别?

线性回归预测得到的是一个数值，而逻辑回归预测到的数值只有0、1两个值。逻辑回归是在线性回归的基础上，加上一个sigmoid函数，让其值位于0-1之间，最后获得的值大于0.5判断为1，小于等于0.5判断为0

二、逻辑回归的推导

\(\hat y\)表示预测值，\(y\)表示训练标签值

1、一般公式
\[
\hat y = wx + b
\]

2、向量化

\[
\hat y = w^Tx+b
\]

3、激活函数
引入sigmoid函数（用\(\sigma\)表示)，使\(\hat y\)值位于0-1

\[
\hat y = \sigma (w^Tx+b)
\]

4、损失函数
损失函数用\(L\)表示

\[
L(\hat y ,y) = \frac 1 2 (\hat y - y) ^ 2
\]

因梯度下降效果不好，换用交叉熵损失函数

\[
L(\hat y,y) = - [y\log \hat y + (1-y)\log(1-\hat y)]
\]

5、代价函数
代价函数用\(J\)表示
\[
J(w,b) = \frac 1 m \sum_{i=1}^m L(\hat y^{(i)},y^{(i)})
\]
展开
\[
J(w,b) = - \frac 1 m \sum_{i=1}^m [y^{(i)}\log \hat y^{(i)} + (1-y^{(i)})\log(1-\hat y ^ {(i)})]
\]

6、正向传播
\[
a = 5,b=3,c=2
\]
\[
u = bc \to 6
\]
\[
v = a + u \to 11
\]
\[
J = 3v \to 33
\]

7、反向传播

求出\(da\) = 3，表示\(J\)对\(a\)的偏导数

\[
J = 3v \to \frac {dJ} {da} = \frac {dJ} {dv} \frac {dv} {da} = 3
\]

求出\(db\) = 6

\[
J = 3v \to \frac {dJ} {dc} = \frac {dJ} {dv} \frac {dv} {du} \frac {du} {dc} = 3c = 6
\]

求出\(dc\) = 6

\[
J = 3v \to \frac {dJ} {db} = \frac {dJ} {dv} \frac {dv} {du} \frac {du} {db} = 3b = 9
\]

对Sigmod函数求导

\[
\sigma (z) = \frac 1 {1 + e ^ {-z}} = s
\]
\[
dz = \frac {e^{-z}}{(1 + e^{-z}) ^ 2}
\]
\[
dz = \frac 1 {1 + e^{-z} } (1 - \frac 1 {1+e^{-z}})
\]
\[
=\sigma(z)(1-\sigma(z))
\]
\[
=s(1-s)
\]

8、反向传播的意义

修正参数，使代价函数值减少，预测值接近实际值。

举个例子：

(1) 玩一个猜数游戏，目标数字为150。

(2) 输入训练样本值: 你第一次猜出一个数字为x = 10

(3) 设置初始权重: 设置一个权重值，比如权重w设为0.5

(4) 正向计算： 进行计算，获得值wx

(5) 求出代价函数： 出题人说差了多少（说的不是具体数字，而是用0-10表示，10表示差的离谱，1表示非常接近，0表示正确）

(6) 反向传播或求导： 你通过出题人的结论，去一点点修正权重（增加w或减少w）。

(7) 重复(4)操作，直到无限接近或等于目标数字。

机器学习，就是在训练中改进、优化，找到最有泛化能力的规则。

三、神经网络实现

1、实现激活函数Sigmoid


def sigmoid(z):
    s = 1.0 / (1.0 + np.exp(-z))
    return s

2、参数初始化


def initialize_with_zeros(dim):
    w = np.zeros([dim,1])
    b = 0
    return w, b

3、前后向传播


def propagate(w, b, X, Y):
    m = X.shape[1]
    A = sigmoid(np.dot(w.T,X) + b)
    cost = (- 1.0 / m ) * np.sum(Y*np.log(A) + (1-Y)*np.log(1-A))
    dw = (1.0 / m) * np.dot(X,(A - Y).T)
    db = (1.0 / m) * np.sum(A - Y)

    cost = np.squeeze(cost)
    grads = {"dw": dw,"db": db}

    return grads, cost

4、优化器实现


def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):

    costs = []

    for i in range(num_iterations):

        # Cost and gradient calculation
        grads, cost = propagate(w,b,X,Y)

        # Retrieve derivatives from grads
        dw = grads["dw"]
        db = grads["db"]

        # update rule
        w = w - learning_rate * dw
        b = b - learning_rate * db

        # Record the costs
        if i % 100 == 0:
            costs.append(cost)

        # Print the cost every 100 training iterations
        if print_cost and i % 100 == 0:
            print ("Cost after iteration %i: %f" %(i, cost))

    params = {"w": w,
              "b": b}

    grads = {"dw": dw,
             "db": db}

    return params, grads, costs

5、预测函数

def predict(w, b, X):
    m = X.shape[1]
    Y_prediction = np.zeros((1,m))
    w = w.reshape(X.shape[0], 1)
    # Compute vector "A" predicting the probabilities of a cat being present in the picture
    A = sigmoid(np.dot(w.T,X)+b)

    for i in range(A.shape[1]):
        # Convert probabilities A[0,i] to actual predictions p[0,i]
        if A[0][i] <= 0.5:
            Y_prediction[0][i] = 0
        else:
            Y_prediction[0][i] = 1

    return Y_prediction

6、代码模块整合


def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):

    # initialize parameters with zeros (≈ 1 line of code)
    w, b = initialize_with_zeros(train_set_x.shape[0])

    # Gradient descent (≈ 1 line of code)
    parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)

    # Retrieve parameters w and b from dictionary "parameters"
    w = parameters["w"]
    b = parameters["b"]

    Y_prediction_test = predict(w, b, X_test)
    Y_prediction_train = predict(w, b, X_train)

    # Print train/test Errors
    print("train accuracy: {} %".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))
    print("test accuracy: {} %".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))

    d = {"costs": costs,
         "Y_prediction_test": Y_prediction_test,
         "Y_prediction_train" : Y_prediction_train,
         "w" : w,
         "b" : b,
         "learning_rate" : learning_rate,
         "num_iterations": num_iterations}

    return d

7、运行程序


d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)

结果

Cost after iteration 0: 0.693147
Cost after iteration 100: 0.584508
Cost after iteration 200: 0.466949
Cost after iteration 300: 0.376007
Cost after iteration 400: 0.331463
Cost after iteration 500: 0.303273
Cost after iteration 600: 0.279880
Cost after iteration 700: 0.260042
Cost after iteration 800: 0.242941
Cost after iteration 900: 0.228004
Cost after iteration 1000: 0.214820
Cost after iteration 1100: 0.203078
Cost after iteration 1200: 0.192544
Cost after iteration 1300: 0.183033
Cost after iteration 1400: 0.174399
Cost after iteration 1500: 0.166521
Cost after iteration 1600: 0.159305
Cost after iteration 1700: 0.152667
Cost after iteration 1800: 0.146542
Cost after iteration 1900: 0.140872
train accuracy: 99.04306220095694 %
test accuracy: 70.0 %

8、更多的分析


learning_rates = [0.01, 0.001, 0.0001]
models = {}
for i in learning_rates:
    print ("learning rate is: " + str(i))
    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)
    print ('\n' + "-------------------------------------------------------" + '\n')

for i in learning_rates:
    plt.plot(np.squeeze(models[str(i)]["costs"]), label= str(models[str(i)]["learning_rate"]))

plt.ylabel('cost')
plt.xlabel('iterations (hundreds)')

legend = plt.legend(loc='upper center', shadow=True)
frame = legend.get_frame()
frame.set_facecolor('0.90')
plt.show()

9、测试图片

## START CODE HERE ## (PUT YOUR IMAGE NAME)
my_image = "my_image.jpg"   # change this to the name of your image file
## END CODE HERE ##

# We preprocess the image to fit your algorithm.
fname = "images/" + my_image
image = np.array(ndimage.imread(fname, flatten=False))
my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((1, num_px*num_px*3)).T
my_predicted_image = predict(d["w"], d["b"], my_image)

plt.imshow(image)
print("y = " + str(np.squeeze(my_predicted_image)) + ", your algorithm predicts a \"" + classes[int(np.squeeze(my_predicted_image)),].decode("utf-8") +  "\" picture.")

结果

y = 0.0, your algorithm predicts a "non-cat" picture.

参考文档

神经网络和深度学习-吴恩达——Course1 Week2

原文地址：https://www.cnblogs.com/fonxian/p/10459762.html

时间： 2024-10-07 13:00:45

实现逻辑回归-神经网络的相关文章

线性回归, 逻辑回归与神经网络公式相似点

线性回归, 逻辑回归与神经网络公式相似点 线性回归与逻辑回归 线性回归的损失函数 \[ J(\theta)={1\over{2m}}\sum_{i=1}^{m}(h_\theta(x^{(i)})-y^{(i)})^2 \] 逻辑回归的损失函数 \[ J(\theta)={-1\over{m}}[\sum_{i=1}^{m}y^{(i)}log(h_\theta(x^{(i)}))+(1-y^{(i)})log(1-h_\theta(x^{(i)}))] \] 线性回归的损失函数的梯度 \[ {

Stanford大学机器学习公开课（三）：局部加权回归、最小二乘的概率解释、逻辑回归、感知器算法

(一)局部加权回归 通常情况下的线性拟合不能很好地预测所有的值,因为它容易导致欠拟合(under fitting).如下图的左图.而多项式拟合能拟合所有数据,但是在预测新样本的时候又会变得很糟糕,因为它导致数据的 过拟合(overfitting),不符合数据真实的模型.如下图的右图. 下面来讲一种非参数学习方法——局部加权回归(LWR).为什么局部加权回归叫做非参数学习方法呢?首先,参数学习方法是这样一种方法:在训练完成所有数据后得到一系列训练参数,然后根据训练参数来预测新样本的值,这时不再依赖

Stanford机器学习---第三讲. 逻辑回归和过拟合问题的解决 logistic Regression &amp; Regularization

原文地址:http://blog.csdn.net/abcjennifer/article/details/7716281 本栏目(Machine learning)包括单参数的线性回归.多参数的线性回归.Octave Tutorial.Logistic Regression.Regularization.神经网络.机器学习系统设计.SVM(Support Vector Machines 支持向量机).聚类.降维.异常检测.大规模机器学习等章节.所有内容均来自Standford公开课machin

机器学习：逻辑回归

************************************** 注:本系列博客是博主学习Stanford大学 Andrew Ng 教授的<机器学习>课程笔记.博主深感学过课程后,不进行总结很容易遗忘,根据课程加上自己对不明白问题的补充遂有此系列博客.本系列博客包括线性回归.逻辑回归.神经网络.机器学习的应用和系统设计.支持向量机.聚类.将维.异常检测.推荐系统及大规模机器学习等内容. ************************************** 逻辑回归 分类(C

机器学习 (三) 逻辑回归 Logistic Regression

文章内容均来自斯坦福大学的Andrew Ng教授讲解的Machine Learning课程,本文是针对该课程的个人学习笔记,如有疏漏,请以原课程所讲述内容为准.感谢博主Rachel Zhang 的个人笔记,为我做个人学习笔记提供了很好的参考和榜样. § 3.  逻辑回归 Logistic Regression 1 分类Classification 首先引入了分类问题的概念——在分类(Classification)问题中,所需要预测的$y$是离散值.例如判断一封邮件是否属于垃圾邮件.判断一个在线交

embedding based logistic regression-神经网络逻辑回归tensorflow

--- 灵感 --- 因为最近一直在做rnn based NLP,其中无论是什么cell,lstm, GRU或者cnn都是基于单词的embedding表示:单词的embdding就是把每个单词表示成一个向量, 然后通过bp训练这些向量的值,这种想法很奇妙,于是我尝试性的把这种思想用在logistic regression上面: --- 问题 --- 对于logistic regression的话,很多向量都是categorial,如果碰到有1000个category怎么做?转换成1000*1的o

逻辑回归LR

逻辑回归算法相信很多人都很熟悉,也算是我比较熟悉的算法之一了,毕业论文当时的项目就是用的这个算法.这个算法可能不想随机森林.SVM.神经网络.GBDT等分类算法那么复杂那么高深的样子,可是绝对不能小看这个算法,因为它有几个优点是那几个算法无法达到的,一是逻辑回归的算法已经比较成熟,预测较为准确:二是模型求出的系数易于理解,便于解释,不属于黑盒模型,尤其在银行业,80%的预测是使用逻辑回归:三是结果是概率值,可以做ranking model:四是训练快.当然它也有缺点,分类较多的y都不是很适用.下

[机器学习] Coursera ML笔记 - 逻辑回归（Logistic Regression）

引言 机器学习栏目记录我在学习Machine Learning过程的一些心得笔记,涵盖线性回归.逻辑回归.Softmax回归.神经网络和SVM等等,主要学习资料来自Standford Andrew Ng老师在Coursera的教程以及UFLDL Tutorial,Stanford CS231n等在线课程和Tutorial,同时也参考了大量网上的相关资料(在后面列出). 前言 本文主要介绍逻辑回归的基础知识,文章小节安排如下: 1)逻辑回归定义 2)假设函数(Hypothesis function

机器学习（四）—逻辑回归LR

1.关于模型在各个维度进行不均匀伸缩后,最优解与原来等价吗?  答:等不等价要看最终的误差优化函数.如果经过变化后最终的优化函数等价则等价.明白了这一点,那么很容易得到,如果对原来的特征乘除某一常数,则等价.做加减和取对数都不等价. 2. 过拟合和欠拟合如何产生,如何解决?  欠拟合:根本原因是特征维度过少,导致拟合的函数无法满足训练集,误差较大:  解决方法:增加特征维度:  过拟合:根本原因是特征维度过大,导致拟合的函数完美的经过训练集,但对新数据的预测结果差.  解决方法:(1)减少特征维