吴恩达 machine learning 编程作业 python实现 ex4

# -*- coding: utf-8 -*-
"""
Created on Wed Jul  1 22:37:49 2020

@author: cheetah023
"""
import numpy as np
import scipy.io as sci
import scipy.optimize as opt

#函数定义
def sigmoid(X):
    return 1 / (1 + np.exp(-X))
def sigmoidGradient(X):
    g = sigmoid(X) * (1 - sigmoid(X))
    return g
def nnCostFunction(nn_params, input_layer_size, hidden_layer_size,
                   num_labels, X, y, lamda):
    #print('nn_params',nn_params.shape)
    theta1 = np.reshape(nn_params[0:hidden_layer_size*(input_layer_size+1)],
                        [hidden_layer_size,input_layer_size+1])
    theta2 = np.reshape(nn_params[hidden_layer_size*(input_layer_size+1):],
                        [num_labels, hidden_layer_size+1])
    m = X.shape[0]
    ones = np.ones([m,1])
    X = np.column_stack([ones,X])
    a2 = sigmoid(np.dot(X,theta1.T))#5000*25
    a2 = np.column_stack([ones,a2])#5000*26
    a3 = sigmoid(np.dot(a2,theta2.T))#5000*10
    y_t = np.zeros([m,num_labels])
    for i in range(0,m):
        y_t[i,y[i]-1] = 1
    cost = np.sum(-y_t * np.log(a3) - (1-y_t) * np.log(1-a3)) / m
    
    theta1_t = theta1[:,1:]
    #print('theta1_t:',theta1_t.shape)
    theta2_t = theta2[:,1:]
    reg = (np.sum(theta1_t ** 2) + np.sum(theta2_t ** 2)) * lamda / (2 * m)
    #print('reg:',reg)
    cost = cost + reg
    return cost
def nnGradient(nn_params, input_layer_size, hidden_layer_size,
                   num_labels, X, y, lamda):
    m = X.shape[0]
    ones = np.ones([m,1])
    X = np.column_stack([ones,X])
    
    theta1 = np.reshape(nn_params[0:hidden_layer_size*(input_layer_size+1)],
                        [hidden_layer_size,input_layer_size+1])
    theta2 = np.reshape(nn_params[hidden_layer_size*(input_layer_size+1):],
                        [num_labels, hidden_layer_size+1])
    theta1_grad = np.zeros(theta1.shape);#25*401
    theta2_grad = np.zeros(theta2.shape);#10*26
    theta1_t = theta1[:,1:]#25*400
    theta2_t = theta2[:,1:]#10*25
    y_t = np.zeros([m,num_labels])
    for i in range(0,m):
        y_t[i,y[i]-1] = 1
    for i in range(0,m):
        z2 = np.dot(X[i,:],theta1.T)#1*25
        a2 = sigmoid(z2)#1*25
        a2 = np.hstack((1,a2))#1*26
        a3 = sigmoid(np.dot(a2,theta2.T))#1*10
        delta3 = a3 - y_t[i,:]#1*10
        delta2 = np.dot(delta3,theta2_t) * sigmoidGradient(z2)#1*25
        
        delta2 = np.reshape(delta2,[1,hidden_layer_size])
        X_t = np.reshape(X[i,:],[1,input_layer_size+1])
        delta3 = np.reshape(delta3,[1,num_labels])
        a2 = np.reshape(a2,[1,hidden_layer_size+1])
        
        theta1_grad = theta1_grad + np.dot(delta2.T,X_t)#25*401
        theta2_grad = theta2_grad + np.dot(delta3.T,a2)#10*26
    theta1_grad[:,0] = theta1_grad[:,0] / m
    theta1_grad[:,1:] = theta1_grad[:,1:] / m + (lamda/m) * theta1_t
    theta2_grad[:,0] = theta2_grad[:,0] / m
    theta2_grad[:,1:] = theta2_grad[:,1:] / m + (lamda/m) * theta2_t
    #grad = np.vstack((theta1_grad.reshape(-1,1),theta2_grad.reshape(-1,1)))
    grad = np.concatenate((theta1_grad.flatten(), theta2_grad.flatten()))
    return grad
def randInitializeWeights(L_in, L_out):
    W = np.zeros([L_out, 1 + L_in]);
    epsilon_init = 0.12
    W = np.random.rand(L_out,1+L_in) * 2 * epsilon_init - epsilon_init
    return W
def predict(Theta1, Theta2, X):
    m = X.shape[0]
    ones = np.ones([m,1])
    X = np.column_stack([ones,X])
    a2 = sigmoid(np.dot(X,theta1.T))#5000*25
    a2 = np.column_stack([ones,a2])#5000*26
    a3 = sigmoid(np.dot(a2,theta2.T))#5000*10
    p = np.argmax(a3,axis = 1) + 1
    p = np.reshape(p,[m,1])
    return p
# Setup the parameters you will use for this exercise
input_layer_size  = 400;  # 20x20 Input Images of Digits
hidden_layer_size = 25;   # 25 hidden units
num_labels = 10;          # 10 labels, from 1 to 10   

#Part 1: Loading and Visualizing Data
data1 = sci.loadmat('ex4data1.mat')
#print(data.keys())
X = data1['X']
y = data1['y']
print('X:',X.shape)
print('y:',y.shape)

#Part 2: Loading Parameters
data2 = sci.loadmat('ex4weights.mat')
#print(data2.keys())
theta1 = data2['Theta1']
theta2 = data2['Theta2']
print('theta1:',theta1.shape)
print('theta2:',theta2.shape)

#Part 3: Compute Cost (Feedforward)
lamda = 0
nn_params = np.vstack((theta1.reshape([-1,1]),theta2.reshape([-1,1])))
cost = nnCostFunction(nn_params, input_layer_size, hidden_layer_size,
                   num_labels, X, y, lamda)
print('Cost at parameters (loaded from ex4weights):',cost)
print('(this value should be about 0.287629)');

#Part 4: Implement Regularization
lamda = 1
cost = nnCostFunction(nn_params, input_layer_size, hidden_layer_size,
                   num_labels, X, y, lamda)
print('Cost at parameters (loaded from ex4weights):',cost)
print('(this value should be about 0.383770');

#Part 5: Sigmoid Gradient
g = sigmoidGradient(np.array([-1, -0.5, 0, 0.5, 1]))
print('Sigmoid gradient evaluated at [-1 -0.5 0 0.5 1]:  ');
print(g);

#Part 6: Initializing Pameters 
initial_Theta1 = randInitializeWeights(input_layer_size, hidden_layer_size)
initial_Theta2 = randInitializeWeights(hidden_layer_size, num_labels)
initial_nn_params = np.vstack((initial_Theta1.reshape([-1,1]),
                               initial_Theta2.reshape([-1,1])))
#Part 7: Implement Backpropagation(时间有点紧,就没实现检查梯度的函数)
#Part 8a: Implement Regularization
lamda = 3
cost = nnCostFunction(nn_params, input_layer_size, hidden_layer_size,
                   num_labels, X, y, lamda)
print('Cost at (fixed) debugging parameters (lambda = 3):',cost)
print('(for lambda = 3, this value should be about 0.576051)')

#Part 8b: Training NN
lamda = 1

#TNC跑出来0.84-0.88,CG跑出来0.96左右
result = opt.minimize(fun=nnCostFunction,
                      x0=initial_nn_params,
                      args=(input_layer_size,hidden_layer_size,num_labels,X,y,lamda),
                      #method='TNC',#truncated Newton algorithm
                      method='CG',#conjugate gradient algorithm
                      jac=nnGradient,
                      options={'maxiter': 50})
'''
#和opt.minimize的参数method='CG'时等价
nnParam = opt.fmin_cg(f=nnCostFunction, x0=initial_nn_params, fprime=nnGradient,
                     args=(input_layer_size, hidden_layer_size,num_labels, X, y, lamda),
                     maxiter=50, disp=True)
'''
nnParam = result.x
theta1 = np.reshape(nnParam[0:hidden_layer_size*(input_layer_size+1)],
                        [hidden_layer_size,input_layer_size+1])
theta2 = np.reshape(nnParam[hidden_layer_size*(input_layer_size+1):],
                        [num_labels, hidden_layer_size+1])
#Part 9: Visualize Weights(没画图)
#Part 10: Implement Predict
p = predict(theta1, theta2, X)
temp = (p == y)
prob = np.mean(temp)
print('Training Set Accuracy:',prob)

运行结果:

X: (5000, 400)
y: (5000, 1)
theta1: (25, 401)
theta2: (10, 26)
Cost at parameters (loaded from ex4weights): 0.2876291651613189
(this value should be about 0.287629)
Cost at parameters (loaded from ex4weights): 0.38376985909092365
(this value should be about 0.383770
Sigmoid gradient evaluated at [-1 -0.5 0 0.5 1]:  
[0.19661193 0.23500371 0.25       0.23500371 0.19661193]
Cost at (fixed) debugging parameters (lambda = 3): 0.5760512469501331
(for lambda = 3, this value should be about 0.576051)
Training Set Accuracy: 0.9634

总结:

1、画图的功底还是差了些,时间少就没法画了

2、矩阵运算的时候,大多数问题都是维度的问题,先查这个会比较省时间

3、刚开始使用opt.minimize的时候忘了设置最大迭代次数,导致好久都没跑完,等了个寂寞

 

 

热门文章

暂无图片
编程学习 ·

MySQL不完全干货教程(持续更新中)

已经有很多教程面面俱到、事无巨细,但实际上能用到的、消化的内容很少。本文聚焦于常见的使用场景,给出MySQL用法和基本原理说明。为便于实践和消化,同时提供了很多案例和脚本。 为了读者进一步深入学习、掌握自我升级的方法,提供了一些权威文档的参考。希望能帮助MySQL初中…
暂无图片
编程学习 ·

Vue

常用指令文本插值 v-html:把文本解析为 HTML 代码。 绑定属性 v-bind:为 HTML 标签绑定属性值。 条件渲染v-if:条件性的渲染某元素,判定为真时渲染,否则不渲染。 v-else:条件性的渲染。 v-else-if:条件性的渲染。 v-show:根据条件展示某元素,区别在于切换的是 display …
暂无图片
编程学习 ·

Leetcode 题解 - 栈和队列

用栈实现队列 232. Implement Queue using Stacks (Easy) 栈的顺序为后进先出,而队列的顺序为先进先出。使用两个栈实现队列,一个元素需要经过两个栈才能出队列,在经过第一个栈时元素顺序被反转,经过第二个栈时再次被反转,此时就是先进先出顺序。 class MyQueue {private …
暂无图片
编程学习 ·

综合练习

一、端午节的淘宝粽子交易 import pandas as pd import numpy as npdf1 = pd.read_csv(zongzi.csv) df1.head()标题价格付款人数店铺发货地址0五芳斋粽子礼盒 心悦+18只装咸鸭蛋组合端午节礼品团购嘉兴肉粽子1296人付款五芳斋官方旗舰店浙江 嘉兴1北京稻香村端午粽子手工豆沙粽…
暂无图片
编程学习 ·

docker安装卡死在boot2docker.iso的下载

安装docker遇到的问题,转载记录一下。 方法一: docker安装需要最新的boot2docker.iso,从docker的安装界面复制网址,我安装的日期是20180823,此时的boot2docker.iso地址为boot2docker.iso,这个地址貌似被墙了,需要翻墙下载,将下载好的文件放到对应文件夹下,我的电脑上为…
暂无图片
编程学习 ·

咸鱼软件应用—VMware下安装ubantu

咸鱼软件应用—VMware下安装ubantuubantu简介开源下载地址在VMware虚拟机安装ubantu系统 为了测试固件需要安装Linux系统,后面有测试说明。现在先把ubantu系统装上再说~ubantu简介 ubuntu基于linux的免费开源桌面PC操作系统,十分契合英特尔的超极本定位,支持x86、64位和ppc架…
暂无图片
编程学习 ·

LeetCode题解(0788):进制转换的奇技淫巧

题目 我们称一个数 X 为好数, 如果它的每位数字逐个地被旋转 180 度后,我们仍可以得到一个有效的,且和 X 不同的数。要求每位数字都要被旋转。 如果一个数的每位数字被旋转以后仍然还是一个数字, 则这个数是有效的。0, 1, 和 8 被旋转后仍然是它们自己;2 和 5 可以互相旋转…
暂无图片
编程学习 ·

Codeforces 1295D Same GCDs(欧拉函数)

传送门题意:给定,若,求有多少个x满足题解:如果满足gcd相同则x必须为gcd(a,m)的倍数,设,则若,有多个w满足。因为d是最大公因数所以。到这里(凭借丰富的骗分经验?)就可以直接猜一波答案是phi(v)了。所以求个gcd再求个欧拉函数就完事儿。一开始欧拉函数没写好还T了一发.…
暂无图片
编程学习 ·

最大子段和

题目描述:N个整数组成的序列a11,a22,a33,…,ann, 求该序列如aii+ai+1i+1+…+ajj的连续子段和的最大值。当所给的整数均为负数时和为0。 例如:-2,11,-4,13,-5,-2,和最大的子段为:11,-4,13。和为20。 Input 第1行:整数序列的长度N(2 <= N <= 50000) 第2 - N + 1行:…
暂无图片
编程学习 ·

排序算法之插入排序、希尔排序、归并排序(C#)

插入排序 两次for循环,外层从数组第二位i=1开始,内层for循环由i向前进行判断,大于则将该位置与遍历位置交换。此时注意,不能按i的位置获取元素,应将该元素暂存,因为交换时对应i位置元素值会变换。c#代码如下/// <summary>/// 插入排序/// </summary>/// <…
暂无图片
编程学习 ·

JMXTrans入门教程

概述 官网 GitHub JMX JMX,即Java Management Extensions,监控Java应用程序系统运行的状态信息,通过分析JMX信息,可用于监控应用程序运行状态、优化程序、排查问题。 JMXTrans JMXTrans是一款开源的JMX指标采集工具,使用简单方便,无需编写代码,只需要配置文件就可以轻松…
暂无图片
编程学习 ·

从永远到永远-SpringCloud项目实战(七)-前端框架NUXT

1、什么是服务端渲染 服务端渲染又称SSR (Server Side Render)是在服务端完成页面的内容,而不是在客户端通过AJAX获取数据。 服务器端渲染(SSR)的优势主要在于:更好的 SEO,由于搜索引擎爬虫抓取工具可以直接查看完全渲染的页面。 如果你的应用程序初始展示 loading 菊花图,…
暂无图片
编程学习 ·

第四天:Spark Streaming

Spark Streaming概述 1. Spark Streaming是什么 Spark Streaming用于流式数据的处理。Spark Streaming支持的数据输入源很多,例如:Kafka、Flume、Twitter、ZeroMQ和简单的TCP套接字等等。数据输入后可以用Spark的高度抽象原语如:map、reduce、join、window等进行运算。而结果…
暂无图片
编程学习 ·

ssm实现用户管理系统

ssm实现用户管理系统(2) @RequestMapping("/add.do") public String add(User user){userService.add(user);return "redirect:findAll.do"; } @RequestMapping("/toUpdate.do") public ModelAndView toUpdate(int id){User user=userService.…
暂无图片
编程学习 ·

平面扫描(Plane-sweeping)介绍

平面扫描(Plane-sweeping)介绍: Reference:三维重建之平面扫描算法(Plane-sweeping) plane-sweeping算法在三维重建中非常重要,其特别适合并行计算,因此通过GPU加速后可以使复杂的稠密重建达到实时。大多实时三维重建的深度图生成部分采用plane-sweeping算法。而且plane…
暂无图片
编程学习 ·

算法笔记:字符串哈希初步

问题描述: 给出N个字符串,每个字符串由三位大写字母组成,再给出M个查询字符串,问每个查询字符串在N个字符串中出现的次数? 解题思路: 把字符串转化为整数,利用空间来换时间效率。 C/C++代码: #include<cstdio> #include<cstring> const int maxn=100; char…
暂无图片
编程学习 ·

ROS学习笔记(十七):rviz之用户指导

1.Troubleshooting 如果您遇到问题并且没有看到下面的答案,请尝试“故障排除”页面 2.Install or build rviz 2.1 Install from debian repository Until fuerte: sudo apt-get install ros-fuerte-visualizationFrom groovy on: sudo apt-get install ros-groovy-rviz # or s…
暂无图片
编程学习 ·

DateUtil 时间工具类

时间工具类 /*** 操作时间工具类s*/ public class DateUtil extends DateUtils {//判断两个日期时间是否相距一天之内,一天之内返回true,否则反手falsepublic static boolean judgmentDate(String date1, String date2) throws Exception {SimpleDateFormat sdf = new Simple…