第四周周报

一、深度学习模块

1.问题解析、函数模型

例题是四个人去不去看电影有没有联系的问题，已知前四天的情况，预测第五天小强去不去看电影。 设定函数 Z = Aw1 + Bw2 + Cw3， 其中w1, w2, w3 分别是如花，小倩，小明去不去看电影对小强去不去看电影的影响权重，三层模型如图所示：

2.数据集、权重初始化

L1隐藏层设定为4个神经元，那么w0应该设置为3X4的权重矩阵，从而用矩阵计算 Z = Aw1 + Bw2 + Cw3
同理，L1层输出有4个，L2层神经元只有一个，那么W1应该设定为4X1的矩阵（每个输出都给一个权重系数）。

2.1代码实现

# 对照上面的问题情况列成矩阵--数据集
x = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])   # x是四组ABC去不去看电影的数据 
y = array([[0, 1, 1, 0]]).T    # y是小强前四次结果数据

# 权重初始化---随机给一组值-1～1的权重
random.seed(1)                                           
w0 = random.random((3, 4)) * 2 - 1       # 第一层权重矩阵
w1 = random.rand((4, 1)) * 2 - 1				 # 第二层权重矩阵

3.FP正向传播过程

3.1第一层

输入是表示如花、小倩、小明是否去看电影的4X3的矩阵，W0是3X4的第一层权重系数矩阵，做乘后输出4X4的Z1矩阵，用sigmoid函数将Z1矩阵映射在0-1范围内，从而得到第一层输出L1。

3.2第二层

同理，将第一层的输出L1（4X4）作为第二层的输入矩阵，W1作为第二层的权重系数矩阵（4X1），做乘后输出Z2（4X1），同样用sigmoid函数将Z2矩阵映射在0-1范围内，从而得到第二层输出L2这就实现了从输入层L0经过隐藏层，输出层，得到输出L2的过程。

3.3代码实现

def fp(Input):
    z1 = dot(Input, w0)                  # 第一层矩阵乘后的输出Z1
    l1 = 1 / (1 + exp(-z1))              # 第一层sigmoid映射后的输出

    z2 = dot(l1, w1)                       # 第二层
    l2 = 1 / (1 + exp(-z2))
    return l1, l2

这里的sigmoid如何将Z输出矩阵映射到0-1上----->

4.BP反向传播过程

反向传播的过程目的是为了更新权重系数，从而找到LOSSmin时的权重系数。如何找到Lossmin就相当于数学问题上的一个导数跟极值的关系。比如定义 Loss函数为error = 1/2(y-yture)**2，那么error就是一个凸函数，凸函数的极小值在导数为0的时候取得，因此如何找到Lossmin变成了根据导数大小，不断调整权重系数的过程了。 而每多一层，就相当于链式求导过程往回推复合函数分别对w0，w1求偏导的过程。

4.1代码实现

def bp(l1, l2, y):
    error = y - l2                          # 反向第一层--误差
    slope = l2 * (1 - l2)                   # sigmoid函数导数
    l1_Delta = slope * error                        

    l0_slope = l1 * (1 - l1)                # 反向第二层的导数
    l0_error = l1_Delta.dot(w1.T)           # 反向第二层的误差
    l0_Delta = l0_slope * l0_error
    
    return l0_Delta, l1_Delta

5.训练

for it in range(10000):
    l0 = x
    l1, l2 = fp(l0)                                 # 正向l1跟l2的sigmoid映射
    l0_delta, l1_delta = bp(l1, l2, y)              # 反向

    w1 = w1 + dot(l1.T, l1_delta)                   # 更新权重
    w0 = w0 + dot(l0.T, l0_delta)

6.整体代码和结果验证

from numpy import random, dot, exp, array

# 争相
def fp(Input):
    z1 = dot(Input, w0)                  # 第一层矩阵乘后的输出Z1
    l1 = 1 / (1 + exp(-z1))              # 第一层sigmoid映射后的输出

    z2 = dot(l1, w1)                       # 第二层
    l2 = 1 / (1 + exp(-z2))
    return l1, l2


# 反向
def bp(l1, l2, y):
    error = y - l2                             # 误差
    slope = l2 * (1 - l2)                    #
    l1_Delta = slope * error                        # 反向第一层增量

    l0_slope = l1 * (1 - l1)                # 反向第二层的导数
    l0_error = l1_Delta.dot(w1.T)           # 反向第二层的误差
    l0_Delta = l0_slope * l0_error
    return l0_Delta, l1_Delta

# 数据集
x = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])       # X表示去还是不去的4X3矩阵
y = array([[0, 1, 1, 0]]).T                                   # 转秩，向量y


# 初始化权重向量
random.seed(1)                                           # 随机数初始值一样，seed(n)中的n相当于密钥key，使用了该key,随机数就一样
w0 = random.random((3, 4)) * 2 - 1
w1 = random.random((4, 1)) * 2 - 1


# 训练
for it in range(10000):
    l0 = x
    l1, l2 = fp(l0)                                 # 正向l1跟l2的sigmoid映射
    l0_delta, l1_delta = bp(l1, l2, y)              # 反向

    w1 = w1 + dot(l1.T, l1_delta)                   # 更新权重
    w0 = w0 + dot(l0.T, l0_delta)

print(fp([[0, 0, 1]])[1])                           # 验证001的情况，返回元组的第二个值也就是l2
print(fp([[1, 1, 1]])[1])
print(fp([[1, 0, 1]])[1])
print(fp([[0, 1, 1]])[1])
print(fp([[1, 1, 0]])[1])                            # 预测项

对比验证答案对正确的。

二、python学习

1、datetime模块-时间和日期

1、获取当前时间-→ a = datetime.datetime.now()，这个函数获得的类型是class类型，是一个对象

可以分别直接用a.year—a.month----a.day----a.hour----a.minute—a.second 方法使用年，月之类的

2、函数 .strftime(‘格式’)格式化生成字符串日期时间。 datetime模块下datetime类里面的strptime方法datetime.datetime.strptime(str_time, ‘str_time对应的格式’)，可以将字符串日期转换成python的datetime对象

3、datetime对象可以直接用减法，因此当需要用到相隔多少天时，可以将时间先全转换为datetime对象再用减法直接相减------→p023

4、日期加减天数后是哪个日期–→用timedelta()函数

timedelta()函数的构造：
datetime.timedelta(days=0, seconds=0, minutes=0, hours=0, weeks=0)
当对参数设定具体的值，达到计算的要求，如：设定：days=1 ，则在原有日期上增加1天；
设定：minutes=-1 ，则在原有时间上减少1分钟
。这个函数会生成一个timedelta类型的数字，可以用datetime对象加减timedelta类型，从而实现日期加减多少天，分，时-----→p024

5、Unix时间缀转换成日期时间，利用datetime.fromtimestamp方法返回POSIX 时间戳对应的本地日期和时间，POSIX时间戳是UTC+00:00 1970年1月1日0时0分0秒起至现在的总秒数，不考虑润秒。而time模块的time()方法可以得到浮点型的unix时间缀，例如 a = time.time()

datetime.datetime.fromtimestamp(unix_time) ------→p026

2、代码实现

p022_日期时间模块，字符串时间与datetime对象转换

import datetime

current_time = datetime.datetime.now()
print(current_time, type(current_time))


str_current_time = current_time.strftime("%Y-%m-%d %H:%M:%s")
print(str_current_time, type(str_current_time))

print('year', current_time.year)
print('month', current_time.month)
print('day', current_time.day)

str_time = '2022, October, 9'

date_time = datetime.datetime.strptime(str_time, "%Y, %B, %d")


''' 这里不不能直接datetime.strptime(str_time, " xxxxxx ")，因为我只声明了datetime模块，而我要用的是datetime模块里面的datetime类下面
的strptime方法。   并且注意括号内的 格式化部分要跟字符串部分对齐。%B表示英文月份全称
'''

print(date_time)

————————————————————————————————

p023_日期之间相减

import datetime

str_birthday = "1998-07-13"
current_time = datetime.datetime.now()

datetime_birthday = datetime.datetime.strptime(str_birthday, "%Y-%m-%d")
live_day = (current_time - datetime_birthday).days  
# datetime对象直接相减得到的类型是timedelta类型。这里用.days将timedelta转成int了

print(f"i have live {live_day} days")
print(type(live_day))

python中可以直接用datetime对象进行相减，得到timedelta类型的日期相隔天数，这里用了.days将timedelta类型转为int类型，如果不用.days，datetime相减结果的timedelta类型会留下来小时，分钟一些没有用的数据。

————————————————————————————————

p024_日期加减天数计算

import datetime


def diff_date(str_date, days):
    date_time = datetime.datetime.strptime(str_date, '%Y-%m-%d')
    time_gap = datetime.timedelta(days=days)		#time_gap是timedelta类型
    new_date = (date_time + time_gap).strftime('%Y-%m-%d')   # datetime对象转换成str输出，用datetime格式输出会有小时，分钟
    print(new_date)


str_current_date = '2022-10-09'
diff_date(str_current_date, -10)
diff_date(str_current_date, 10)

datetime模块里面又有datetime对象类型（时间），timedelta类型（时间差）。

————————————————————————————————

p025_输出日期之间所有日历

import datetime


def get_range(date1, date2):
    date_range = []
    while date1 <= date2:  # 能用字符串直接比较是因为date1跟date2格式一致，ASCII按位比较
        date_range.append(date1)
        time_gap = datetime.timedelta(days=1)  # time_gap为delta类型，用于datetime对象类型计算
        date_date1 = datetime.datetime.strptime(date1, '%Y-%m-%d')
        date_date1 = date_date1 + time_gap
        date1 = date_date1.strftime('%Y-%m-%d')  # 再转为datetime对象类型，方便while循环里面的比较大小
    print(date_range)


str_date1 = '2022-10-1'
str_date2 = '2022-10-9'
get_range(str_date1, str_date2)

————————————————————————————————

p026_unix时间缀转日期时间

import time
import datetime


t = time.time()			# 获得当前unix时间缀
print(t, type(t))

date_date = datetime.datetime.fromtimestamp(t)	  # 将unix时间缀转为datetime对象类型时间
str_date = date_date.strftime('%Y-%m-%d %H:%M:%S') # 将datetime对象类型转为字符型时间格式化
print(str_date)

总结

深度学习这周主要看了李宏毅的前几节课，然后找了个demo做了个简单的例子理解了数学原理，python这周还是每天做几个例题学习，没遇到什么问题。下周准备读第二篇文献，然后学习几个神经网络，然后每天做python例题