作业2-1

（1）

（2）

import numpy as np
import matplotlib.pyplot as plt

class Network(object):
def __init__(self, num_of_weights):
# 随机产生w的初始值
# 为了保持程序每次运行结果的一致性，设置固定的随机数种子
#np.random.seed(0)
self.w_1 = np.random.randn(num_of_weights, num_of_weights)
self.b_1 = np.zeros(num_of_weights)
#定义第二层的初始权重
self.w_2=np.random.randn(num_of_weights,1)
self.b_2=0.

def forward_1(self, x):
z = np.dot(x, self.w_1) + self.b_1
return z

def forward_2(self,x):
z=np.dot(x,self.w_2)+self.b_2
return z

def loss(self, z, y):
error = z - y
num_samples = error.shape[0]
cost = error * error
cost = np.sum(cost) / num_samples
return cost

def gradient(self, x, y, z):
#z = self.forward_1(x) or 为2
N = x.shape[0]
gradient_w = 1. / N * np.sum((z-y) * x, axis=0)
gradient_w = gradient_w[:, np.newaxis]
gradient_b = 1. / N * np.sum(z-y)
return gradient_w, gradient_b

def update_1(self, gradient_w, gradient_b, eta = 0.01):
self.w_1 = self.w_1 - eta * gradient_w
self.b_1 = self.b_1 - eta * gradient_b

def update_2(self, gradient_w, gradient_b, eta = 0.01):
self.w_2=self.w_2 - eta * gradient_w
self.b_2 = self.b_2 - eta * gradient_b

def train(self, training_data, num_epoches, batch_size=10, eta=0.01):
n = len(training_data)
losses = []
for epoch_id in range(num_epoches):
# 每轮迭代开始之前，将训练数据的顺序打乱，
# 然后再按每次取batch_size条数据的方式取出
np.random.shuffle(training_data)
# 将训练数据进行拆分，每个mini_batch包含batch_size条的数据
mini_batches = [training_data[k:k+batch_size] for k in range(0, n, batch_size)]
for iter_id, mini_batch in enumerate(mini_batches):
#print(self.w.shape)
#print(self.b)
x = mini_batch[:, :-1]
y = mini_batch[:, -1:]
#前向传播
a_1 = self.forward_1(x)
a_2=self.forward_2(a_1)

#反向传播第二层的
loss = self.loss(a_2, y)
gradient_w_2, gradient_b_2 = self.gradient(a_1, y,self.forward_2(a_1))
self.update_2(gradient_w_2, gradient_b_2, eta)

#反向传播第一层的
gradient_w_1,gradient_b_1=self.gradient(x,a_1,self.forward_1(x))
self.update_1(gradient_w_1,gradient_b_1,eta)

losses.append(loss)
print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.
format(epoch_id, iter_id, loss))

return losses

# 获取数据
train_data, test_data = load_data()

# 创建网络
net = Network(13)
# 启动训练
losses = net.train(train_data, num_epoches=50, batch_size=100, eta=0.1)

# 画出损失函数的变化趋势
plot_x = np.arange(len(losses))
plot_y = np.array(losses)
plt.plot(plot_x, plot_y)
plt.show()

作业3-1（1）

import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.patches as patches

plt.figure(figsize=(8, 3))

def tanh(x):
y = (np.exp(x) - np.exp(- x)) / (np.exp(x) + np.exp(- x))
return y
x = np.arange(-10, 10, 0.1)

# 画图
plt.plot(x, tanh(x), color='r')
plt.text(-7., 0.9, r'$y=\tanh(x)$', fontsize=13)
currentAxis=plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)
plt.show()

作业3-1（2）

import numpy as np
p=np.random.randn(10,10)
q=(p>0)
sum=np.sum(q)
print(sum)

作业8：

relu：

sigmoid：

可以看到使用relu激活函数在验证集上的loss和accuracy震荡更小而且更加稳定

作业9-1：在1000－3000步设置0.01， 在3000步设0.001

作业9-1：

boundaries = [150,300]

values=[0.01,0.001,0.0001]

可见使用分段衰减后，accuracy可以达到0.96甚至0.97

作业9-2：

代码修改：

（1）train中使用分段衰减的学习率；

（2）网络构成修改：

（3）网络前向输出：

验证集上的结果：

跑Googlenet报错，说内存不足

作业7-2

是不是把Batch写的太大的，如果实在跑不起来可以改小一点

我改为2也不行

作业3-1 使用numpy计算tanh激活函数

程序代码：

import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.patches as patches

#设置图片大小
#plt.figure(figsize=(8, 3))

# x是1维数组，数组大小是从-10. 到10.的实数，每隔0.1取一个点
x = np.arange(-10, 10, 0.1)
# 计算 tanh函数
y = (np.exp(x) - np.exp(-x))/(np.exp(x) + np.exp(-x))

#画出训练过程中Loss的变化曲线
plt.figure()
plt.title("y = tanh(x)", fontsize=14)
plt.xlabel("x", fontsize=14)
plt.ylabel("y", fontsize=14)
plt.plot(x, y,color='red',label='y = tanh(x)') 
plt.grid()
plt.show()

作业3-1（2）统计随机生成矩阵中有多少个元素大于0

import numpy as np

p = np.random.randn(10, 10)
#print(type(p))
print(p.shape)
print(p)
q = (p > 0) #对矩阵p的每个元素进行判断
print(q.dtype)

q = q.astype('int32') # bool类型转换成int32类型
print(q)
#print(q.sum(axis=1)) #按行求和
#print(q.sum(axis=0)) #按列求和
q.sum() # 对每个元素求和

作业3：

3-1： 用numpy实现tanh函数的计算，并画出其函数曲线

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(-10, 11, 1)
y = (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))

plt.figure(figsize=(5, 3))
plt.plot(x, y)
plt.text(-7, 0.7, r'$y=tanh(x)$', fontsize=13)
currentAxis = plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)
plt.show()

3-2：统计随机生成矩阵中有多少个元素大于0

import numpy as np

p = np.random.randn(10, 10)
q = (p>0)
#print(q)
print('大于0的个数：{}'.format(np.sum(q)))

作业2

2-1：

作业3 

3-1：重新提交

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(-10, 10, 0.1)
y = (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))

plt.figure(figsize=(5, 3))
plt.plot(x, y)
plt.text(-7, 0.7, r'$y=tanh(x)$', fontsize=13)
currentAxis = plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)
plt.show()

分段衰减学习率，如何打印出训练过程中的具体学习率？

作业7-1：

输出一个像素点需要：

乘法 9次

加法 8次加法+1次偏置项加法=9次加法

单层数据[224, 224]卷积不填充输出数据[222, 222]，输出像素点为222*222

因此：

一次卷积需要的乘法=9*222*222*3*64*10=851627520次

一次卷积需要的加法=9*222*222*3*64*10=851627520次

作业7-2

作业在这里交么？是不是我来晚了?这个班结束了吗？

结束了，现在是NLP，作业在另一个帖子交

NLP的在这https://ai.baidu.com/forum/topic/show/957882

因为：

$$H_{out} = \frac{H + 2p_h - k_h}{s_h} + 1$$

$$W_{out} = \frac{W + 2p_w - k_w}{s_w} + 1$$

所以，总计算量为：

加法数=$9*10*64*224*2224=289013760$

乘法数也一样