用Python动手学机器学习读书笔记（一）

第一章 机器学习

一.关于机器学习

1.机器学习：从数据中总结规律的统计方法。
2.神经网络模型：使用多个神经元（神经细胞模型）的方法。
3.深度学习：在多个层使用大量神经元的方法。
机器学习 包含 神经网络模型 包含 深度学习。

1.1.1学习机器学习窍门

1.降维：高维公式令D=2
2.编写程序：验证是否真正理解数学式。
3.编程得出结果后，绘制图形，重现计算过程。将数值和函数可视化。

1.1.2机器学习中问题的分类

1.三种：有监督学习，无监督学习，强化学习。
有监督学习：要求对输入给出相应的输出。
无监督学习：要求发现输入数据的规律。
强化学习：找出能使最后结果达到最优的动作。

二.用Anaconda安装Python

1.3.1 Jupyter Notebook的使用

1.在Jupyter Notebook中启动Python
Anaconda3—>JupyterLab（在浏览器中出现）—>添加Notebook&Python3—>创建了.ipynb文件
2.单元格
命令模式：单击左侧。对单元格本身进行操作。
编辑模式：单击文本框。
3.快捷键
Ctrl+Enter：运行

1.3.2输入Markdown格式文本

1.先选中markdown模式再输入文本,先输入文本再转成markdown都行。
code模式：用于编写python代码模式。
markdown模式：标记模式，编写普通文本。
2.markdown模式中
#加空格加文本：标题。
##或者###会使标题层级下降。

1.3.3更改文件名

默认untitled，单击可变更，保存为.ipynb文件。
.ipynb文件：使用 Jupyter Notebook 来编写Python程序时的文件。

四.安装Keras与TensorFlow

1.Anaconda3 —> Anaconda Powershell Prompt启动windows powershell
2.使用命令pip install tensorflow==2.13.1
3.使用命令pip install keras==2.13.1
注：下载速度过慢，关了重下，30s下完。
tensorflow与keras与python有版本对应，未详细考察。

4.在Jupyter Notebook中输入 ，会输出keras版本号

keras.__version__   

第二章 Python基础知识

一.常见函数（别忘赋值给新变量）

1.print()函数

x='zd'
print("x="+str(x))     # 其中的+表示字符串的拼接。

x=12
print('weight:{}kg'.format(x))   # 表示将{}中的内容替换为x，中间有.间隔开

x=11
y=12
z=13
print('weight:{0}kg，{1}kg，{2}kg'.format(x,y,z))   # 表示将{0}中的内容替换为x,{1}中的内容替换为y,{2}中的内容替换为z。数值从0开始。

x=1/3
y=1/4
z=1/5
print('weight:{0:.2f}kg，{1:.2f}kg，{2:.2f}kg'.format(x,y,z))   # {数值:.nf}表示保留小数点后n位。

for letter in 'APPLE':
    print("字母：%s"%letter)    # 中间无逗号或者句号，前一个%数据类型，后一个%变量名。

字母：A
字母：P
字母：P
字母：L
字母：E

2.type()函数

表示显示元素的类型

x='123'
print(type(x))

3.列表中的x[i]与x[i]=a

列表，元组，range等类型中用来选择或改变第i+1个元素，i从0开始。

x=[1,2,3]
print(x[1])
x[1]=100
print(x)

4.range()函数

range函数也是一种变量类型。type()的结果还是range(a,b),不是列表。
range(n)表示从0到n，间隔为1的左闭右开区间。
range(a,b)表示从a到b，间隔为1的左闭右开区间。
range函数和列表很像，可以使用print，list，len，x[i]=n等函数。

x=range(5)
y=range(2,5)
print(x)
list(x)
list(y)
print(x)
print(y)

5.list()函数

将变量转换成列表类型

y=range(2,5)
z=list(y)
print(z)

[2, 3, 4]

6.len函数

获取list的长度.包括range函数等
例：有列表[1,2,3,4,5],将其中的元素都乘2.
法一：

num=[1,2,3,4,5]
for i in range(len(num)):  # range(5)
    num[i]=num[i]*2
print(num)

法二：

i=0
num=[1,2,3,4,5]
for n in num:
    num[i]=n*2
    i+=1
print(num)

法三：

num=[1,3,5,7,9]
for i,n in enumerate(num):
    num[i]=n*2
print(num)

7.enumerate函数

常用于for函数中，将一个遍历对象(列表，元组，字符串)组合成索引序列，可通过每个值所在位置的编号进行访问。编号从0开始。
先编号，后元素。

for i,n in enumerate(num):

8.np.array函数
x=np.array([1,2,3])

8.矩阵中np.arange函数

使用np.arange(n)生成元素值递增的向量数组,生成值从0到n-1的整数左开右闭区间。np.arange(a,b)生成值从a到b的左闭右开区间，间距为1。

x=np.arange(9)
print(x)

[0 1 2 3 4 5 6 7 8]

x=np.arange(1.5,9)
print(x)

[1.5 2.5 3.5 4.5 5.5 6.5 7.5 8.5]

9.矩阵中“a.copy()”函数与列表中“copy.deepcopy()”函数

注：
b=a.copy()。变量名在前，括号内为空。
b=copy.deepcopy(a)。变量名在括号内。
变量名.copy()用于向量中表示新定义一个矩阵与原来相同，不同的地址。
例一：

a=np.array([1,1])
b=a
print('a='+str(a))
print('b='+str(b))
b[0]=100
print('b='+str(b))
print('a='+str(a))

a=[1 1]
b=[1 1]
b=[100 1]
a=[100 1]

用b=a，此时a，b完全相同，无论改变a还是b，其结果完全相同。
例二：

a=np.array([1,1])
b=a.copy()
print('a='+str(a))
print('b='+str(b))
b[0]=100
print('b='+str(b))
print('a='+str(a))

a=[1 1]
b=[1 1]
b=[100 1]
a=[1 1]

此时a与b是不同的的两个向量。
例三：

a=[1,2,3]
b=a
print(a)
print(b)
b[2]=100
print(a)
print(b)

[1, 2, 3]
[1, 2, 3]
[1, 2, 100]
[1, 2, 100]

用b=a，此时a，b完全相同，无论改变a还是b，其结果完全相同。

例四：

import copy
a=[1,2,3]
b=copy.deepcopy(a)
print(a)
print(b)
b[2]=100
print(a)
print(b)

[1, 2, 3]
[1, 2, 3]
[1, 2, 3]
[1, 2, 100]

只改变b中元素的值。

10.矩阵中“变量名.shape”函数

矩阵的大小可以用ndarray类型的“变量名.shape”获取。结果为ndarray类型。
其结果可以命名为整型，或者向量类型。先行后列

x=np.array([[1,2,3],[4,5,6]])
print(x.shape)

(2, 3)

x=np.array([[1,2,3],[4,5,6]])
h,l=x.shape
m=x.shape
print(h)
print(h)
print(m)

2
3
(2,3)

11.矩阵中“np.zeros(size)”函数与“np.ones(size)”函数

所有元素都为0的ndarray可以用**np.zeros(size)生成。
所有元素为1的ndarray可以用np.ones(size)**生成。
size为元素个数，可以一维或高维。
size是tuple类型。不可更改。

import numpy as np
x=np.zeros(10)
print(x)
y=np.zeros((2,10))
print(y)

[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]

注：输出数字中间带.也是矩阵。

12.矩阵中“np.random.rand(size)函数“，”np.random.randn(size)函数“与“np.random.randint(low，high，size)函数”

可以用np.random.rand(size)生成元素随机的矩阵，元素为0-1的随机数，8位有效数字。
想生成2* 3的随机数矩阵，要用np.random.rand(2,3),而不是np.random.rand((2,3))
每次运行代码生成矩阵的元素值都不相同。

x=np.random.rand(2,3)
print(x)
print(type(size))

[[0.30825642 0.24511424 0.15190682]
[0.55753316 0.49659016 0.01841091]]
<class ‘tuple’>

np.random.randn(size)函数可以生成由服从均值为0，方差为1的高斯分布的随机数构成的矩阵。
np.random.randint(low，high，size)可以生成由low到high-1的随机整数构成的大小为size的矩阵。

x=np.random.randn(10)
print(x)

[ 0.52983748 -1.1371181 0.17195231 -1.30758704 -0.53544926 -0.64334057 0.91736007 1.37345926 -2.17782549 0.0988242 ]

x=np.random.randint(1,3,(2,2))
print(x)

[[2 2]
[2 2]]

元素为1到2的随机整数，二维，每一维有两个元素。

x=np.random.randint(3,(2,2))
print(x)

此时元素为0到3的随机整数，二维，每一维有两个元素。

13.矩阵中“变量名.reshape(n,m)”函数

想改变矩阵的大小，需要使用“变量名.reshape(n,m)”。其中n* m要等于原来元素的总个数

a=np.arange(8)
print(a)
a=a.reshape(2,4)
print(a)

[0 1 2 3 4 5 6 7]
[[0 1 2 3]
[4 5 6 7]]

14.矩阵中算术函数

numpy中有各种算术函数。
如：np.sqrt(x)计算平方根，或者矩阵中每个元素的平方根。
指数函数np.exp(x)
对数函数np.log(x)
用于四舍五入的函数np.round(x,小数点后的位数)
均值函数np.mean（x）
标准差函数np.std(x)
求最大值的函数np.max(x)
求最小值的函数np.min(x)
对每个元素四舍五入为最近整数np.round(x)
对每个元素四舍五入,保留n位小数np.round(x,n)

15.矩阵中“矩阵A.dot(矩阵B)”函数

矩阵v和矩阵w的乘积可以用v.dot(w)计算。

v=np.array([[1,2,3],[4,5,6]])
w=np.array([[1,1],[2,2],[3,3]])
z=v.dot(w)
print(z)

[[14 14]
[32 32]]

16.查询函数help(函数名)

17.保存ndarray类型变量的

18.矩阵中“np.save(‘文件名.npy’，变量名)”与“np.load(‘文件名.npy’)”函数

用于保存一个或者多个ndarray变量
1.一个ndarray
保存：使用函数np.save(‘文件名.npy’，变量名)
读取：np.load(‘文件名.npy’)
2.多个ndarray
保存：np.savez(‘文件.npz’,新变量名1=原变量名1，新变量名2=原变量名2，…).
读取：np.load(‘文件名.npz’)
注：新变量名，原变量名一般相同。
例：一个ndarray

data=np.array([1,2,3,5,8,13])
print(data)
np.save('datafile.npy',data)  #保存文件
data_1=np.load('datafile.npy') #读取文件
print(data_1)

[ 1 2 3 5 8 13]
[ 1 2 3 5 8 13]

例：多个ndarray

a=np.array([1,2,3,4])
b=np.array([5,6,7,8])
np.savez('data.npz',x=a,b=b)
c=np.load('data.npz')
a_1=c['x']
print(a)

注：此时c不是列表，属于字典。不能用c[0],c[1]读取，需要用变量名读取c[‘x’],c[‘b’]

二.概念及区分

一.四则运算

1.满足先乘积后加减的运算顺序
2.幂计算：2**3=8

二.变量

int 整型
float 实数
str 字符串
bool 布尔
list 数组(可变)：列表,注：
tuple 数组(不可变)：元组
numpy.ndarray 向量，矩阵：n维数组类型。简称ndarray类型。

三.列表与元组

x=[1,2,3] 列表，可变
y=(1,2,3) 元组，不可变
元组变列表：list(y)
tuple无变量类型，无函数表示。
2.二维数组

a=[[1,2,3],[4,5,6]]
print(a)

[[1,2,3],[4,5,6]]

元素读取：

a=[[1,2,3],[4,5,6]]
print(a[1])    # 读取第二个数组
print(a[0][1])  # 读取第一个数组第二个元素
# 注：序号还是从0开始。

[4,5,6]
2

3.长度为1的元组
x=(1,) 表示长度为1的元组
x=(1) 表示整型元素1,()表示运算顺序的

四.if语句

if _____:
    ________
else:
    ________

1.缩进4个格
2.if后面比较语句的计算结果为bool类型
3.单次if语句else之后可省略
4.x>10 and x<20与 10<x<20 相同

五.for语句

例：若元素i在列表A中，则遍历输出i。

A=[1,2,3]
for i in A:
    print(i)

1
2
3

注：A可以遍历字符串，列表，元组，集合，字典
有多少元素，遍历多少次。

六.向量（一维数组）

1.在python中想要使用向量或者矩阵，需要导入Numpy库。

import numpy as np

2.向量(一维数组)使用np.array定义

（list类型）也是ndarray类型。

x=np.array([1,2])
print(type(x))

[1 2]
numpy.ndarray

3.相加

向量相加为对应元素相加。
列表相加，为两个列表的拼接。

import numpy as np
x=[1,2]
y=[3,4]
print(x+y)
a=np.array([1,2])
b=np.array([3,4])
print(a+b)

[1,2,3,4]
[4 6]

4.读取与替换

与list类型一样，用x[i],x[i]=n，从0开始。

5.向量的注意事项

注：在使用ndarray类型时，不能用b=a，Python会把“a中内容的储存地址的引用”赋给b，会同时改变a，b的值。list类型也会。想不改变a的值，需要“b=a.copy（)”

注：list会出现相同的现象，想仅复制可以先import copy，再b=copy.deepcopy(a).

七.矩阵

1.定义矩阵

可以使用ndarray的二维数组定义矩阵。注意有双层中括号。各个维度之间要用“，”分隔开。

x=np.array([[1,2,3],[4,5,6]])
print(x)

[[1 2 3]
[4 5 6]]

2.矩阵的大小

矩阵的大小可以用ndarray类型的“变量名.shape”获取。输出结果为tuple类型。(行，列)。

3.读取元素与替换元素

与list类型一样，用x[i,j],x[i,j]=n，从0开始。
x[i]表示读取第i+1维的元素。

4.生成元素为0和1的ndarray

所有元素都为0的ndarray可以用**np.zeros(size)生成。
所有元素为1的ndarray可以用np.ones(size)**生成。

5.生成元素随机的矩阵

可以用np.random.rand(size)生成元素随机的矩阵，元素为0-1的随机数，8位有效数字。
此时size不再是tuple类型。
*想生成2x3的随机数矩阵，要用np.random.rand(2,3),而不是np.random.rand((2,3))
每次运行代码生成矩阵的元素值都不相同。

np.random.randn(size)函数可以生成由服从均值为0，方差为1的高斯分布的随机数构成的矩阵。
np.random.randint(low，high，size)可以生成由low到high-1的随机整数构成的大小为size的矩阵。

6.改变矩阵大小

想改变矩阵的大小，需要使用“变量名.reshape(n,m)”。其中n* m要等于原来元素的总个数

7.1矩阵的四则运算

(1).在使用四则运算的时候，实际计算的是对应的各个元素相加减。

x=np.array([[4,4,4],[8,8,8]])
y=np.array([[1,1,1],[2,2,2]])
print(x+y)

[[ 5 5 5]
[10 10 10]]

(2)标量乘矩阵

x=np.array([[4,4,4],[8,8,8]])
y=x*10
print(y)

[[40 40 40]
[80 80 80]]

(3)算术函数
numpy中有各种算术函数。
如：np.sqrt(x)计算平方根，或者矩阵中每个元素的平方根。
指数函数np.exp(x)
对数函数np.log(x)
用于四舍五入的函数np.round(x,小数点后的位数)
均值函数np.mean（x）
标准差函数np.std(x)
求最大值的函数np.max(x)
求最小值的函数np.min(x)

(4)计算矩阵乘积
矩阵v和矩阵w的乘积可以用v.dot(w)计算。

7.2列表，元组，数组，向量，矩阵的区分

1.列表元组：列表与元组的元素可以是整型、浮点型、布尔型、字符串等等。
向量矩阵： 数组向量矩阵的元素只能为数字或者符号。
数组：一种数据结构，是相同类型元素的集合或有序序列。2.列表元组可以储存任意类型的值。数组只能储存相同类型的元素。
3.列表元组由[ ]包含，中间有，隔开
向量矩阵由[ ]包含，中间无符号

[[1 2 3]  
[1 2 3]]

[[1, 2, 3], [1, 2, 3]]

4.向量一维，矩阵二维或多维。
5.数组：list
元组：tuple
向量矩阵：numpy.ndarray 简称ndarray类型

8.切片

list类型与ndarray类型都具有切片功能，可以把元素的一部分汇总起来使用。切片用：表示。
例一:对于np.arange(x)
“变量名[:n]”可以一次性读取0到第n个的元素。
“变量名[n:]”可以读取第n+1个元素到末尾的元素。
“变量名[n1:n2:dn]”为每隔dn个元素，从n1+1个元素到第n2个元素，读取一个元素。
“变量名[::-1]”实现一维数组的逆序输出。多维数组，维数逆序输出(每一维元素顺序不变)。

x=np.arange(10)
print(x)
print(x[:6])
print(x[6:])
print(x[2:6:1])
print(x[::-1])

[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5]
[6 7 8 9]
[2 3 4 5]
[9 8 7 6 5 4 32 1 0]

例二：对于np.arange(a,b)
“变量名[:n]”可以一次性读取a到第n个的元素。“变量名[n:]”可以读取第n+1个元素到末尾。
“变量名[a:b]”读取的是从第a+1个到第b个元素。
“变量名[n1:n2:dn]”为每隔dn个元素，从第n1+1个元素到第n2个元素，读取一个元素。
“变量名[::-1]”实现数组的逆序输出。多维数组，维数逆序输出(每一维元素顺序不变)。

x=np.arange(2,10)
print(x)
print(x[:6])
print(x[6:])
print(x[2:6:1])
print(x[::-1])

[2 3 4 5 6 7 8 9]
[2 3 4 5 6 7]
[8 9]
[4 5 6 7]
[9 8 7 6 5 4 3 2]

总结：无论arange函数是否限定开始数字。当冒号两边有数字a或b时，a表示第a+1个元素，b表示第b个元素。'空’表示最开头或者最末尾。

例：二维矩阵的逆序输出。只逆序维数，不改变每一维的元素

x=np.array([[1,2,3],[4,5,6]])
print(x)
print(x[::-1])

[[1 2 3]
[4 5 6]]
[[4 5 6]
[1 2 3]]

例：三维矩阵的切片

y=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(y)
print(y[:2,1:2])

[[1 2 3]
[4 5 6]
[7 8 9]]
[[2]
[5]]

三维矩阵的切片：
数字表示第几个。
逗号前为维度的切片范围，逗号后为元素的切片范围。
[;2]表示维度为最开始到第二维，[1:2]表示元素为第二个元素。

9.替换矩阵中满足条件的数据(bool数组的用法)

在numpy(数组库)中，可以从储存在矩阵的数据中提取满足条件的数据，并加以替换。
如定义数组x，令x>3，会输出一个显示元素值为bool类型的数组，元素为True或False。
使用bool数组读取数组元素，是会输出满足条件的元素
还把满足条件的元素替换掉。

x=np.array([1,1,2,3,5,8,13])
y=x[x>3]
print(y)
x[x>3]=999
print(x)

[ 5 8 13]
[ 1 1 2 3 999 999 999]

10.help用法

help(函数名)

11.函数定义def

1.函数可以汇总一部分代码。对于多次使用的代码，用函数封装之后会非常方便。
2.以“def 函数名():”开头，并将函数的内容缩进，即可定义函数。
3.使用“def 函数(a,b):”可以向函数赋值a,b。在return后面写上变量名，即可输出返回值。

例：求和函数

def my_func2(a,b):
    c=a+b
    return c
x=my_func2(1,2)
print(x)

3

4.向函数传入的变量为参数，函数的输出为返回值。
5.参数与返回值可以是任意类型，返回值也可以定义为多个值。

例：输入一维向量，输出数据的平均值与标准差。

import numpy as np
def my_func3(D):
    m=np.mean(D)
    n=np.std(D)
    return m,n
x=[1,2,3,4,5]
print(my_func3(x))

(3.0, 1.4142135623730951)

注:
获取多个返回值时，可以用变量D接收(此时为tuple);或者a,b挨个接收。
如：a，b=my_func3(x)
如：D=my_func3(x)
用变量D接收时，D[0],D[1]表示D中的第一第二元素。

12.保存一个或多个ndarray类型变量

1.一个ndarray
保存：使用函数np.save(‘文件名.npy’，变量名)
读取：np.load(‘文件名.npy’)
2.多个ndarray
保存：np.savez(‘文件.npz’,新变量名1=原变量名1，新变量名2=原变量名2，…).
读取：np.load(‘文件名.npz’)
注：新变量名，原变量名一般相同。

注：此时c不是列表，属于字典。不能用c[0],c[1]读取，需要用变量名读取c[‘x’],c[‘b’]