机器学习/深度学习常见算法实现(秋招版)

包括BN层、卷积层、池化层、交叉熵、随机梯度下降法、非极大抑制、k均值聚类等秋招常见的代码实现。

1. BN层

import numpy as npdef 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, Wvar = 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) * meanrunning_var = momentum * running_var + (1-momentum) * varres = gamma * ( outputs - mean ) / np.sqrt(var + epsilon) + betareturn res, running_mean, running_varif __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 npdef 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 = NoneN, C_in, H, W = x.shapeC_out, _, k1, k2 = w.shapestride, padding = conv_param['stride'], conv_param['pad']H_out = (H-k1+2*padding) // stride + 1W_out = (W-k2+2*padding) // stride + 1out = 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] = xfor 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 npdef 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.shapek1, k2 = kernels1, s2 = strideH_out = (H - k1) // s1 + 1W_out = (W - k2) // s2 + 1out = 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 npdef 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_exploss_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.shapey_ = 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_dataself.epochs = epochsself.batch_size = batch_sizeself.lr = lrself.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 npdef iou_calculate(bbox1, bbox2, mode='x1y1x2y2'):# 我的x11, y11, x12, y12 = bbox1x21, y21, x22, y22 = bbox2area1 = (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 ioudef 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] = Falsescores = 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)  # 将置信度最高的加入结果列表# 计算其他边界框与该边界框的IOUx11 = 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 * hious = 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, scoresdef 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.1print(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 copydef check(clusters_last, clusters_center):# clusters_last.sort()# clusters_center.sort()if len(clusters_last) == 0:return Falsefor c1, c2 in zip(clusters_last, clusters_center):if np.linalg.norm(c1 - c2) > 0:return Falsereturn Truedef 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 choosedwhile 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 = distanceidx = jclusters[idx].append(data[i])clusters_center = []for i in range(k):clusters_center.append(np.mean(clusters[i], axis=0))return clusters_centerdef kMeans2(data, k):''':param data: [n, c]:param k: the number of clusters:return:'''clusters_last = []clusters_center = copy.deepcopy(data[:k]) # random choosedwhile 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_centerif __name__ == '__main__':data = np.random.random((20, 2))print(kMeans(data, 5))print(kMeans2(data, 5))