机器学习/深度学习常见算法实现(秋招版)
包括BN层、卷积层、池化层、交叉熵、随机梯度下降法、非极大抑制、k均值聚类等秋招常见的代码实现。
1. BN层
import numpy as np
def batch_norm(outputs, gamma, beta, epsilon=1e-6, momentum=0.9, running_mean=0, running_var=1):
'''
:param outputs: [B, L]
:param gamma: mean
:param beta:
:param epsilon:
:return:
'''
mean = np.mean(outputs, axis=(0, 2, 3), keepdims=True) # 1, C, H, W
var = np.var(outputs, axis=(0,2,3), keepdims=True) # 1, C, H, W
# mean = np.mean(outputs, axis=0)
# var = np.var(outputs, axis=0)
# 滑动平均用于记录mean和var,用于测试
running_mean = momentum * running_mean + (1-momentum) * mean
running_var = momentum * running_var + (1-momentum) * var
res = gamma * ( outputs - mean ) / np.sqrt(var + epsilon) + beta
return res, running_mean, running_var
if __name__ == '__main__':
outputs = np.random.random((16, 64, 8, 8))
tmp, _, _ = batch_norm(outputs, 1, 1, 1e-6)
# print(tmp.shape)
mean = np.mean(tmp[:, 1, :, :])
std = np.sqrt(np.var(tmp[:, 1, :, :]))
print(mean, std)
2. 卷积层
import numpy as np
def conv_forward_naive(x, w, b, conv_param):
'''
:param x: [N, C_in, H, W]
:param w: [C_out, C_in, k1, k2]
:param b: [C_out]
:param conv_param:
- 'stride':
- 'pad': the number of pixels that will be used to zero-pad the input
:return:
- 'out': (N, C_out, H', W')
- 'cache': (x, w, b, conv_param)
'''
out = None
N, C_in, H, W = x.shape
C_out, _, k1, k2 = w.shape
stride, padding = conv_param['stride'], conv_param['pad']
H_out = (H-k1+2*padding) // stride + 1
W_out = (W-k2+2*padding) // stride + 1
out = np.zeros((N, C_out, H_out, W_out))
x_pad = np.zeros((N, C_in, H+2*padding, W+2*padding))
x_pad[:, :, padding:padding+H, padding:padding+W] = x
for i in range(H_out):
for j in range(W_out):
x_pad_mask = x_pad[:, :, i*stride:i*stride+k1, j*stride:j*stride+k2]
for c in range(C_out):
out[:, c, i, j] = np.sum(x_pad_mask*w[c, :, :, :], axis=(1,2,3))
out += b[None, :, None, None]
cache = (x, w, b, conv_param)
return out, cache
3. maxpooling
import numpy as np
def maxpooling_forward(feature, kernel, stride):
'''
:param feature: [N, C, H, W]
:param kernel: [k1, k2]
:param stride: [s1, s2]
:return:
'''
N, C, H, W = feature.shape
k1, k2 = kernel
s1, s2 = stride
H_out = (H - k1) // s1 + 1
W_out = (W - k2) // s2 + 1
out = np.zeros((N, C, H_out, W_out))
for i in range(H_out):
for j in range(W_out):
feature_mask = feature[:, :, i*s1:i*s1+k1, j*s2:j*s2+k2]
out[:, :, i, j] = np.max(feature_mask, axis=(2,3)) # 注意这里的2,3!!!
return out
4. cross Entropy
import numpy as np
def cross_entropy(label, outputs, reduce=True):
'''
:param label: B x 1
:param outputs: B x c
:return: loss
'''
loss_list = []
for i in range(len(label)):
y = label[i]
output = outputs[i]
sum_exp = np.sum([np.exp(k) for k in output])
prop = np.exp(output[y]) / sum_exp
loss_list.append(-np.log(prop))
if reduce:
return np.mean(loss_list)
else:
return np.sum(loss_list)
def softmax(t):
return np.exp(t) / np.sum(np.exp(t), axis=1, keepdims=True)
def softmax2(t):
return np.exp(t) / np.sum(np.exp(t), axis=1, keepdims=True)
def cross_entropy_2(y, y_, onehot=True, reduce=True):
y = softmax(y)
if not onehot:
cates = y.shape
y_ = np.eye(cates[-1])[y_]
if reduce:
return np.mean(-np.sum(y_ * np.log(y), axis=1))
else:
return np.sum(-np.sum(y_ * np.log(y), axis=1))
if __name__ == '__main__':
outputs = [[0.5, 0.5], [0, 1], [1, 0]]
label = [0, 0, 1]
print(cross_entropy(label, outputs, True))
print(cross_entropy_2(outputs, label, False))
5. sgd
import numpy as np
import random
class MYSGD:
def __init__(self, training_data, epochs, batch_size, lr, model):
self.training_data = training_data
self.epochs = epochs
self.batch_size = batch_size
self.lr = lr
self.weight = [...]
self.bias = [...]
def run(self):
n = len(self.training_data)
for j in range(self.epochs):
random.shuffle(self.training_data)
mini_batches = [self.training_data[k*self.batch_size: (k+1)*self.batch_size]
for k in range(n//self.batch_size)]
for mini_batch in mini_batches:
self.updata(mini_batch)
def update(self, mini_batch):
nabla_b = [np.zeros(b.shape) for b in self.bias]
nabla_w = [np.zeros(w.shape) for w in self.weight]
for x, y in mini_batch:
delta_nabla_b, delta_nabla_w = self.backprop(x, y)
nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
self.weight = [w-(self.eta/len(mini_batch))*nw for w, nw in zip(self.weight, nabla_w)]
self.bias = [b-(self.eta/len(mini_batch))*nb for b, nb in zip(self.bias, nabla_b)]
def backprop(self, x, y):
6. nms
import numpy as np
def iou_calculate(bbox1, bbox2, mode='x1y1x2y2'):
# 我的
x11, y11, x12, y12 = bbox1
x21, y21, x22, y22 = bbox2
area1 = (y12-y11+1)*(x12-x11+1)
area2 = (y22-y21+1)*(x22-x21+1)
overlap = max(min(y12, y22) - max(y11, y21) + 1, 0) * max(min(x12, x22) - max(x11, x21) + 1, 0)
return overlap / (area2 + area1 - overlap + 1e-6)
def bb_intersection_over_union(boxA, boxB):
# 别人的
boxA = [int(x) for x in boxA]
boxB = [int(x) for x in boxB]
xA = max(boxA[0], boxB[0])
yA = max(boxA[1], boxB[1])
xB = min(boxA[2], boxB[2])
yB = min(boxA[3], boxB[3])
interArea = max(0, xB - xA + 1) * max(0, yB - yA + 1)
boxAArea = (boxA[2] - boxA[0] + 1) * (boxA[3] - boxA[1] + 1)
boxBArea = (boxB[2] - boxB[0] + 1) * (boxB[3] - boxB[1] + 1)
iou = interArea / float(boxAArea + boxBArea - interArea)
return iou
def nms(outputs, scores, T):
'''
:param outputs: bboxes, x1y1x2y2
:param scores: confidence of each bbox
:param T: threshold
:return:
'''
# 我的
outputs = np.array(outputs)[np.argsort(-np.array(scores))]
saved = [True for _ in range(outputs.shape[0])]
for i in range(outputs.shape[0]):
if saved[i]:
for j in range(i+1, outputs.shape[0]):
if saved[j]:
iou = iou_calculate(outputs[i], outputs[j])
if iou >= T:
saved[j] = False
scores = np.sort(-np.array(scores))
return outputs[saved], -scores[saved]
# 别人的
def nms_others(bboxes, scores, iou_thresh):
"""
:param bboxes: 检测框列表
:param scores: 置信度列表
:param iou_thresh: IOU阈值
:return:
"""
x1 = bboxes[:, 0]
y1 = bboxes[:, 1]
x2 = bboxes[:, 2]
y2 = bboxes[:, 3]
areas = (y2 - y1) * (x2 - x1)
# 结果列表
result = []
index = scores.argsort()[::-1] # 对检测框按照置信度进行从高到低的排序，并获取索引
# 下面的操作为了安全，都是对索引处理
while index.size > 0:
# 当检测框不为空一直循环
i = index[0]
result.append(i) # 将置信度最高的加入结果列表
# 计算其他边界框与该边界框的IOU
x11 = np.maximum(x1[i], x1[index[1:]])
y11 = np.maximum(y1[i], y1[index[1:]])
x22 = np.minimum(x2[i], x2[index[1:]])
y22 = np.minimum(y2[i], y2[index[1:]])
w = np.maximum(0, x22 - x11 + 1) # 两个边重叠时,也有1列/行像素点是重叠的
h = np.maximum(0, y22 - y11 + 1)
overlaps = w * h
ious = overlaps / (areas[i] + areas[index[1:]] - overlaps)
# 只保留满足IOU阈值的索引
idx = np.where(ious <= iou_thresh)[0]
index = index[idx + 1] # 处理剩余的边框
bboxes, scores = bboxes[result], scores[result]
return bboxes, scores
def mynms(bboxes, scores, iou_T):
x1 = bboxes[:, 0]
y1 = bboxes[:, 1]
x2 = bboxes[:, 2]
y2 = bboxes[:, 3]
areas = (y2-y1+1) * (x2-x1+1)
ids = np.argsort(scores)[::-1]
res = []
while len(ids) > 0:
i = ids[0]
res.append(i)
x11 = np.maximum(x1[i], x1[ids[1:]])
x22 = np.minimum(x2[i], x2[ids[1:]])
y11 = np.maximum(y1[i], y1[ids[1:]])
y22 = np.minimum(y2[i], y1[ids[1:]])
# np.maximum(X,Y,None) : X与Y逐位取最大者. 最少两个参数
overlap = np.maximum(x22-x11+1, 0) * np.maximum(y22-y11+1, 0)
iou = overlap / (areas[i] +areas[ids[1:]] - overlap)
ids = ids[1:][iou<T]
return bboxes[res], scores[res]
if __name__ == '__main__':
outputs = [[10, 10, 20, 20], [15, 15, 25, 25], [9, 15, 25, 13]]
scores = [0.6, 0.8, 0.7]
T = 0.1
print(nms(outputs, scores, T))
print(nms_others(np.array(outputs), np.array(scores), T))
print(mynms(np.array(outputs), np.array(scores), T))
7. k-means
import numpy as np
import copy
def check(clusters_last, clusters_center):
# clusters_last.sort()
# clusters_center.sort()
if len(clusters_last) == 0:
return False
for c1, c2 in zip(clusters_last, clusters_center):
if np.linalg.norm(c1 - c2) > 0:
return False
return True
def kMeans(data, k):
'''
:param data: [n, c]
:param k: the number of clusters
:return:
'''
clusters_last = []
clusters_center = [data[i] for i in range(k)] # random choosed
while not check(clusters_last, clusters_center):
clusters_last = copy.deepcopy(clusters_center)
clusters = [[] for _ in range(k)]
for i in range(data.shape[0]):
min_dis = float('inf')
for j, center in enumerate(clusters_center):
distance = np.linalg.norm(center-data[i])
if distance < min_dis:
min_dis = distance
idx = j
clusters[idx].append(data[i])
clusters_center = []
for i in range(k):
clusters_center.append(np.mean(clusters[i], axis=0))
return clusters_center
def kMeans2(data, k):
'''
:param data: [n, c]
:param k: the number of clusters
:return:
'''
clusters_last = []
clusters_center = copy.deepcopy(data[:k]) # random choosed
while not check(clusters_last, clusters_center):
clusters_last = copy.deepcopy(clusters_center)
clusters = [[] for _ in range(k)]
for i in range(data.shape[0]):
distance = np.linalg.norm(clusters_center - data[i], axis=1)
idx = np.argmin(distance)
clusters[idx].append(data[i])
clusters_center = []
for i in range(k):
clusters_center.append(np.mean(clusters[i], axis=0))
clusters_center = np.array(clusters_center)
return clusters_center
if __name__ == '__main__':
data = np.random.random((20, 2))
print(kMeans(data, 5))
print(kMeans2(data, 5))