本章讲述了最简单的神经网络内容！涉及了很多新的概念，大家可以直接看书里面的。并涉及很多激活函数，代码笔记如下：

矩阵乘法：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/2/14 21:23
# @Author : LZQ
# @Software: PyCharm
import numpy as np
'''

#一维数组

A=np.array([1,2,3,4])
print(A)
print(np.ndim(A))
print(A.shape,A.shape[0])

'''

'''
#二维数组
B=np.array([[1,2],[3,4],[5,6]])
print(B)
print(np.ndim(B),B.shape)
'''
'''
#矩阵乘
A=np.array([[1,2],[3,4]])
B=np.array([[5,6],[7,8]])
print(A.shape)
print(B.shape)
print(np.dot(A,B))
'''
#实现多为数组的神经网络信号传递
def sigmoid(x):
    return 1/(1+np.exp(-x))

X=np.array([1.0,0.5])
#从第0层到1层
W1=np.array([[0.1,0.3,0.5],[0.2,0.4,0.6]])
B1=np.array([0.1,0.2,0.3])

A1=np.dot(X,W1)+B1
Z1=sigmoid(A1)
print("--------0-1---------")

print(A1)
print(Z1)
#从第1层到2层
W2=np.array([[0.1,0.4],[0.2,0.5],[0.3,0.6]])
B2=np.array([0.1,0.2])
A2=np.dot(Z1,W2)+B2
Z2=sigmoid(A2)
print("--------1-2---------")
print(A2)
print(Z2)
# 从第2层到第3层
# 第三层使用恒等函数
def indetity_function(x):
    return x
W3=np.array([[0.1,0.3],[0.2,0.4]])
B3=np.array([0.1,0.2])

A3=np.dot(Z2,W3)+B3
Z3=indetity_function(A3)
print(A3)
print(Z3)

sigmoid函数：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/2/14 20:55
# @Author : LZQ
# @Software: PyCharm
import numpy as np
import matplotlib.pyplot as plt
# sigmoid函数
def sigmoid(x):
    return 1/(1+np.exp(-x))   #np.exp(-x)就是 e 的-x次方

print(sigmoid(2))
x=np.array([-1.0,1.0,2.0])
print(sigmoid(x))#numpy的广播功能  结果：[0.26894142 0.73105858 0.88079708]
x1=np.arange(-5.0,5.0,0.1)
y1=sigmoid(x1)
plt.figure()
plt.plot(x1,y1)
plt.ylim(-0.1,1.1)
plt.show()

阶跃函数：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/2/13 18:36
# @Author : LZQ
# @Software: PyCharm
# 神经网络笔记
import numpy as np
# 01阶跃函数的数值调用
def step_function(x):#实现对数值的调用
    if x>0:
        return 1
    else:
        return 0
#02阶跃函数的数组调用
def step_function2(x):
    y=x>0 #实现对数组的调用
    return y.astype(np.int) #将布尔型转换成int型

def step_function3(x):
    return np.array(x>0,dtype=np.int)

x=np.array([-1.0,1.0,2.0])
print(step_function3(x))
#阶跃函数的图形展示
import matplotlib.pyplot as plt
x1=np.arange(-5.0,5.0,0.1)
y1=step_function3(x1)
plt.figure()
plt.plot(x1,y1)
plt.ylim(-0.1,1.1)#指定y轴的范围
plt.show()

softmax函数

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/2/15 12:18
# @Author : LZQ
# @Software: PyCharm
import numpy as np

def softmax(a):
    exp_a=np.exp(a)
    sum_exp_a=np.sum(exp_a)
    y=exp_a/sum_exp_a

    return y

a=np.array([0.3,2.9,4.0])
print(softmax(a)) #[0.01821127 0.24519181 0.73659691]

'''
上面的softmax函数的实现虽然正确描述了式（3.10），但在计算机的运算
上有一定的缺陷。这个缺陷就是溢出问题。 softmax函数的实现中要进行指
数函数的运算，但是此时指数函数的值很容易变得非常大。比如， e10的值
会超过20000， e100会变成一个后面有40多个0的超大值， e1000的结果会返回
一个表示无穷大的inf。如果在这些超大值之间进行除法运算，结果会出现“不
确定”的情况。

计算机处理“数”时，数值必须在4字节或8字节的有限数据宽度内。
这意味着数存在有效位数，也就是说，可以表示的数值范围是有
限的。因此，会出现超大值无法表示的问题。这个问题称为溢出，
在进行计算机的运算时必须（常常）注意。
'''

#改进softmax函数,防止出现nan 溢出现象

def softmax2(a):
    c=np.max(a)
    exp_a=np.exp(a-c)#溢出对策
    sum_exp_a=np.sum(exp_a)
    y=exp_a/sum_exp_a
    return y

a1=np.array([1010,1000,990])
# print(softmax(a1)) #溢出 [nan nan nan]
print(softmax2(a1))#改进没有，溢出现象

print(np.sum(softmax2(a1))) #softmax的输出数值和为1

ReLU函数

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/2/14 21:15
# @Author : LZQ
# @Software: PyCharm
import numpy as np
import matplotlib.pyplot as plt
def relu(x):
    return np.maximum(0,x)

x=np.arange(-6.0,6.0,1)
y=relu(x)
plt.plot(x,y,'r')
plt.title("relu Function")
plt.ylabel("y")
plt.xlabel("x")
plt.ylim(-1,6)
plt.show()