梯度下降法补充知识

梯度下降

梯度下降是一个用来求函数最小值的算法，我们将使用梯度下降算法来求出代价函数\(J(\theta_0,\theta_1)\)的最小值。

have some function : \(J(\theta_0,\theta_1)\)

want : \(\min_{{\theta_{0}} {\theta_{1}}} J(\theta_0,\theta_1)\)

outline :

• 初始化 \({\theta_{0}}\) 和 \({\theta_{1}}\) , \({\theta_{0}}\) = 0 , \({\theta_{1}}\) = 0
• 不断的改变 \({\theta_{0}}\) 和 \({\theta_{1}}\) 值，不断减少 \(F({\theta_{0}},{\theta_{1}})\) 直至达到最小值（或者局部最小）。

想象成下山，如何下山的速度最快？这里涉及到了下山的速度，即步长。

repeat until convergence\[ \{\theta_j:=\theta_j-{\alpha}\frac{\partial }{\partial {\theta_{0}}}J(\theta_0,\theta_1) (for \quad j=o\quad and\quad j=1) \}\]

• := 赋值
• \(\alpha\) 被称作为学习速率，\(\alpha\)值大，下山的步伐大
• 更新等式，需要同时更新\(\theta_0,\theta_1\)

更新实现方法：

\[ {\begin{align*}\rm{temp}0&:= {\theta_{0}}\alpha *\frac{\partial }{\partial {\theta_{0}\rm{F}({\theta_{0}},{\theta_{1}}) \\\rm{temp}1 &:= {\theta_{1}} \alpha *\frac{\partial }{\partial {\theta_{1}\rm{F}({\theta_{0}},{\theta_{1}}) \\{\theta_{0}} &:= \rm{temp}0 \\{\theta_{1}} &:= \rm{temp}1 \\\end{align*} }\]

直到收敛。注意 \({\theta_{0}}\) 和 \({\theta_{1}}\) 值要同时更新，切记不要求一次导更新一次！

如果 \(\alpha\) 被设置的很小，需要很多次循环才能到底最低点。
如果 \(\alpha\) 被设置的很大，来来回回可能就会离最低点越来越远，会导致无法收敛，甚至发散。

当快要到最低点的时候，梯度下降会越来越慢，因为 \( \frac{\partial }{\partial {\theta}}\) 越来越小。

梯度下降的直观理解

\[\theta_j:=\theta_j-\alpha{\frac{\partial}{\partial{\theta_j}}J(\theta_0,\theta_1)}\]

简化模型：

• \(min_{\theta_0} J(\theta_1)\)
• \(\theta_1 \in \R\)

• 导数求切线斜率
• 此时\(\theta_1\)减去一个大于0的斜率，\(\theta_1\)左移
• 假设你将初始化\(\theta_1\)在局部最低点已经在一个局部的最优处或局部最低点。结果是局部最优点的导数将等于零,\(\theta_1\)不变

\(\alpha\)

• 太小速度会很慢
• 太大会超过最小值

例：

::越接近最小值，下降的斜率越低，下降速度越慢::

try:
    print('try...')
    r = 10 / 0
    print('result:', r)
except ZeroDivisionError as e: 
    print('except:', e)
finally:
    print('finally...') 
print('END')

try...
except: division by zero
finally...
END

try...
except: division by zero finally...
END

try...
result: 5 
finally... 
END

try:
    print('try...') 
    r = 10 / int('a')
    print('result:', r) 
except ValueError as e:
    print('ValueError:', e) 
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e) 
finally:
    print('finally...') 
print('END')

try:
    print('try...') 
    r = 10 / int('2')
    print('result:', r) 
except ValueError as e:
    print('ValueError:', e) 
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e) 
else:
    print('no error!') 
finally:
    print('finally...') 
print('END')

try:
    foo()
except ValueError as e: 
    print('ValueError')
except UnicodeError as e: 
    print('UnicodeError')

Python所有的错误都是从BaseException类派生的，常见的错误类型和继承关系

使用try...except捕获错误还有一个巨大的好处，就是可以跨越多层调用，比如函数main()调用foo()，foo() 调用bar()，结果bar()出错了，这时，只要main()捕获到了，就可以处理：

def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    try:
        bar('0')
    except Exception as e: 
        print('Error:', e)
    finally:
        print('finally...')

也就是说，不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。这样一来，就大大减少了写try...except...finally的麻烦。

python所有的标准异常类：

模块

模块：通俗理解一个.py文件就是一个模块，模块是管理功能代码的。

内置模块：就是python自己内部自带的不需要我们去下载的模块， 比如：time, random等。

自定义模块的使用

注意：自定义模块名字和变量名的定义很类似，都是由字母、数字、下划线组成，但是不能以数字开头，否则无法导入该模块。

创建名为first_module的自定义模块

__all__= ["g_num", "show"]
# 指定 all 表示 from 模块名 import * 只能使用指定的功能代码，而不是所有的功能代码
# 定义全局变量
g_num = 10
# 定义函数 
def show():
    print("我是一个函数")
# 定义类
class Student(object):
    def init (self, name, age): 
        self.name = name
        self.age = age 
    
    def show_msg(self):
        print(self.name, self.age)
# 解决导入的模块中方法没有调用就会执行
if __name__== '__main__': 
    show()

我是一个函数

使用自定义的模块

# 导入模块
import first_module
# 使用模块中的功能代码
print(first_module.g_num) first_module.show()
stu = first_module.Student("李四", 20)
stu.show_msg()

注意：使用 name 查看模块名，执行哪个文件，哪个文件中的__name__输出__main__ , 其他导入模块中的__name__结果就是模块名字。

模块导入的注意点：

1. 自定义的模块名不要和系统的模块名重名，
2. 导入的功能代码不要在当前模块定义否则使用不了导入模块的功能代码

包的介绍

包：通俗理解包就是一个文件夹，只不过文件夹里面有一个init.py文件，包是管理模块的， 模块是管理功能代码的。

# -----import导入包里面的模块----
import first_package.first

#-----import导入包里面的模块设置别名----
import first_package.first as one

#----from导入包名 import 模块名----
from first_package import second

#--- from 包名.模块名 import 功能代码----
from first_package.first import show    # 需要保证当前模块没有导入模块的功能代码
# --- from 包名 import *, 默认不会导入包里面的所有模块，需要在init文件里面使用   all  去指定导入的模块
from first_package import *

__init__文件写法
# 如果外界使用from 包名 import * 不会导入包里面的所有模块，需要使用 all 指定
     all    = ["first", "second"]
# 从当前包导入对应的模块
from . import first from . import second

文件基础操作

文件简介

文件包括文本文件和二进制文件（声音，图像，视频) 从存储方式来说，文件在磁盘上的存储方式都是二进制形式， 所以，文本文件其实也应该算二进制文件。先从他们的区别来说，虽然都是二进制文件，但是二进制代表的意思不一 样。打个比方，一个人，我们可以叫他的大名，以叫他的小名，但其实都是代表这个人。二进制读写是将内存里面的数据直接读写入文本中，而文本呢，则是将数据先转换成了字符串，再写入到文本中。

读文件

要以读文件的模式打开一个文件对象，使用Python内置的open()函数，传入文件名和标示符：

f = open('/Users/michael/test.txt', 'r')

标示符'r'表示读，这样，我们就成功地打开了一个文件。

如果文件不存在，open()函数就会抛出一个IOError的错误，并且给出错误码和详细的信息告诉你文件不存在：

f=open('/Users/michael/notfound.txt', 'r')

---------------------------------------------------------------------------

FileNotFoundError                         Traceback (most recent call last)

<ipython-input-115-56fe20145a26> in <module>()
----> 1 f=open('/Users/michael/notfound.txt', 'r')


FileNotFoundError: [Errno 2] No such file or directory: '/Users/michael/notfound.txt'

如果文件打开成功，接下来，调用read()方法可以一次读取文件的全部内容，Python把内容读到内存，用一个str 对象表示：

f.read() 'Hello, world!'

最后一步是调用close()方法关闭文件。文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源，并且操 作系统同一时间能打开的文件数量也是有限的：

f.close()

由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally来实现：

try:
    f = open('/path/to/file', 'r') 
    print(f.read())
finally:
    if f:
        f.close()

但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法：

with open('/path/to/file', 'r') as f:
    print(f.read())

这和前面的try ... finally是一样的，但是代码更佳简洁，并且不必调用f.close()方法。

调用read()会一次性读取文件的全部内容，如果文件有10G，内存就爆了，所以，要保险起见，可以反复调用read(size)方法，每次最多读取size个字节的内容。另外，调用readline()可以每次读取一行内容，调用readlines()一次读取所有内容并按行返回list。因此，要根据需要决定怎么调用。

如果文件很小，read()一次性读取最方便；如果不能确定文件大小，反复调用read(size)比较保险；如果是配置文件，调用readlines()最方便：

for line in f.readlines():
    print(line.strip()) # 把末尾的'\n'删掉

文件的打开方式

字符编码

要读取非UTF-8编码的文本文件，需要给open()函数传入encoding参数，例如，读取GBK编码的文件：

 f = open('/Users/michael/gbk.txt', 'r', encoding='gbk')
 f.read()
'测试'

遇到有些编码不规范的文件，你可能会遇到UnicodeDecodeError，因为在文本文件中可能夹杂了一些非法编码的 字符。遇到这种情况，open()函数还接收一个errors参数，表示如果遇到编码错误后如何处理。最简单的方式是直接忽略：

f = open('/Users/michael/gbk.txt', 'r', encoding='gbk', errors='ignore')

写文件

写文件和读文件是一样的，唯一区别是调用open()函数时，传入标识符'w'或者'wb'表示写文本文件或写二进制文件：

f = open('/Users/michael/test.txt', 'w')
f.write('Hello, world!')
f.close()

你可以反复调用write()来写入文件，但是务必要调用f.close()来关闭文件。当我们写文件时，操作系统往往不 会立刻把数据写入磁盘，而是放到内存缓存起来，空闲的时候再慢慢写入。只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘。忘记调用close()的后果是数据可能只写了一部分到磁盘，剩下的丢失了。

所以，还是用with语句来得保险：

with open('/Users/michael/test.txt', 'w') as f: f.write('Hello, world!')

要写入特定编码的文本文件，请给open()函数传入encoding参数，将字符串自动转换成指定编码。

注意：以'w'模式写入文件时，如果文件已存在，会直接覆盖（相当于删掉后新写入一个文件）。如果我们希望追加到文件末尾怎么办？可以传入'a'以追加（append）模式写入。