作业链接：https://git-core.megvii-inc.com/ai_train/ai_yanwenhui/-/tree/master/week-1

20210729153038906×524 65.9 KB

作业链接：https://git-core.megvii-inc.com/ai_train/ai_yanwenhui/-/tree/master/week-2
task1


task2

统计

图片crop

image1432×139 80 KB

https://studio.brainpp.com/project/10338?name=AI_第2节课作业

data = np.zeros((n,))
label = np.zeros((n,))

for i in range(n):
    data[i] = np.random.uniform(-10, 10)
    label[i] = w * data[i] + b + np.random.uniform(-noise, noise)
return data, label

print('epoch = {} , w={:.3f}, b={:.3f}, loss:{:.3f}'.format(epoch, m_w.item(), m_b.item(), loss.item()))
x = np.array([-10, 10])
y = m_w * x + m_b
plt.scatter(o_data, o_label, marker=".")
plt.plot(x, y, "-b")
plt.show()

image568×615 55 KB

image455×599 52.7 KB

链接：https://studio.brainpp.com/project/10940?name=AI培训课后作业(4_5)_cuizhihang_作业
结果：

微信截图_20210903174048957×874 40.9 KB

图片增强结果：

image492×658 144 KB

image744×329 21.8 KB

image755×675 45.1 KB

image747×478 24.1 KB

import pickle
import re
import os
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
from imgaug import augmenters as iaa
import cv2

class Cifar10:
class test:
pass
def init(self, path, one_hot = True):
self.path = path
self.one_hot = one_hot
self._epochs_completed = 0
self._index_in_epoch = 0
self._num_examples = 50000

def _load_data(self):
    dic = {}
    images = np.zeros([10000, 3,32,32])
    labels = []
    files = os.listdir(self.path)
    test_images = None
    for file in files:
        if re.match("data_batch_*", file):          
            with open(self.path +"/" + file, 'rb') as fo:       #load train data
                dic = pickle.load(fo, encoding = 'bytes')
                images = np.r_[images, dic[b"data"].reshape([-1,3,32,32])]
                labels.append(dic[b"labels"])
        elif re.match("test_batch", file):          #load test data 
            with open(self.path + "/" + file , 'rb') as fo:
                dic = pickle.load(fo, encoding = 'bytes')
                test_images = np.array(dic[b"data"].reshape([-1, 3, 32, 32]))
                test_labels = np.array(dic[b"labels"])
    dic["train_images"] = images[10000:].transpose(0,2,3,1)
    dic["train_labels"] = np.array(labels).reshape([-1, 1]) 
    dic["test_images"] = test_images.transpose(0,2,3,1)
    dic["test_labels"] = test_labels.reshape([-1, 1])
    if self.one_hot == True:
        dic["train_labels"] = self._one_hot(dic["train_labels"], 10)
        dic["test_labels"] = self._one_hot(dic["test_labels"], 10)

    self.images, self.labels =  dic["train_images"], dic["train_labels"]
    self.test.images, self.test.labels = dic["test_images"], dic["test_labels"]
    return [dic["train_images"], dic["train_labels"], dic["test_images"], dic["test_labels"] ]


def next_batch(self, batch_size,shuffle=True):
    start = self._index_in_epoch
    # Shuffle for the first epoch
    if self._epochs_completed == 0 and start == 0 and shuffle:
        perm0 = np.arange(self._num_examples)
        np.random.shuffle(perm0)
        self._images = self.images[perm0]
        self._labels = self.labels[perm0]
    # Go to the next epoch
    if start + batch_size > self._num_examples:
        # Finished epoch
        self._epochs_completed += 1
        # Get the rest examples in this epoch
        rest_num_examples = self._num_examples - start
        images_rest_part = self._images[start:self._num_examples]
        labels_rest_part = self._labels[start:self._num_examples]
        # Shuffle the data
        if shuffle:
            perm = np.arange(self._num_examples)
            np.random.shuffle(perm)
            self._images = self.images[perm]
            self._labels = self.labels[perm]
        # Start next epoch
        start = 0
        self._index_in_epoch = batch_size - rest_num_examples
        end = self._index_in_epoch
        images_new_part = self._images[start:end]
        labels_new_part = self._labels[start:end]
        return np.concatenate(
            (images_rest_part, images_new_part), axis=0), np.concatenate(
                (labels_rest_part, labels_new_part), axis=0)
    else:
        self._index_in_epoch += batch_size
        end = self._index_in_epoch
        return self._images[start:end], self._labels[start:end]

def _one_hot(self, labels, num):
    size= labels.shape[0]
    label_one_hot = np.zeros([size, num])
    for i in range(size):
        label_one_hot[i, np.squeeze(labels[i])] = 1
    return label_one_hot

def load_cifar10(path, one_hot = True):
cifar10 = Cifar10(path, one_hot)
cifar10._load_data()
return cifar10

path = r"dataset/cifar-10-batches-py"
cifar10 = load_cifar10(path, one_hot = False)
images = cifar10.images
print(“训练集图片：” + str(images.shape))
labels = cifar10.labels
print(“训练集类别：” + str(labels.shape))
test_images1 = cifar10.test.images
print(“测试集图片：”+ str(test_images1.shape))
test_labels = cifar10.test.labels
print(“测试集类别：”+ str(test_labels.shape))
batch_xs, batch_ys = cifar10.next_batch(batch_size = 500, shuffle = True)
print(“batch_xs shape is:” + str(batch_xs.shape))
print(“batch_ys shape is:” + str(batch_ys.shape))

def img_mean_max_min(np_array):
npa = np.array(np_array)
max_w = npa.max(axis=0)
min_h = npa.min(axis=0)
mean_w = npa.mean(axis=0)
mean_h = npa.mean(axis=0)
result_format = [max_w[0],min_h[1],mean_w[0],mean_h[1]]
print(“最大宽: {0}, 最大高: {1},平均宽: {2}, 平均高: {3}”.format(*result_format))

img_shape_list =
for img in images:
img_shape_list.append(list(img.shape))

gap = 16
H, W = 256, 128
NUM = 9
img_mean_max_min(img_shape_list)
sometimes = lambda aug: iaa.Sometimes(0.5, aug)
seq = iaa.Sequential([
iaa.Fliplr(0.5), # 对50%的图像进行镜像旋转
iaa.Flipud(0.2), # 对20%的图像做左右翻转
sometimes(iaa.Crop(px = (0, 100))), # 对随机的一部分图像做crop操作
sometimes(iaa.Affine(
scale={“x”: (0.8, 1.2), “y”: (0.8, 1.2)}, #图像缩放为80% 到120% 之间
translate_percent = {“x”: (-0.2, 0.2), “y”: (-0.2, 0.2)} ,# 平移 ±20%之间
rotate=(-45, 45), # 旋转±45度之间
shear=(-16, 16), # 剪切变换±16度，（矩形变为平行四边形
order=[0,1], # 使用最近相邻差值或者双线性差值
cval = (0, 255), # 全白全黑填充

mode = iaa.ALL # 定义填充图像外区域的方法

)),
iaa.Resize({"height": H, "width": W})

], random_order=True)

res = np.zeros(shape=((H + gap)* len(images), (W + gap)*NUM, 3),dtype = np.uint8)

for img in images:
img_shape_list.append(list(img.shape))
images = np.array(
[img] * NUM,
dtype = np.uint8
)
write_img = np.zeros((H, (W + 10) * NUM, 3), dtype = np.uint8)
images_aug = seq(images = images)
for i, img in enumerate(images_aug):
write_img[:, i*(W+10): i*(W+10)+W, :] = img
plt.imshow(write_img, cmap=“gray”)
plt.show()
break

import megengine as mge
import megengine.functional as F
from megengine.autodiff import GradManager
import megengine.optimizer as optim
import numpy as np
import matplotlib.pyplot as plt

def two_layer_conv(x):
print(x.shape)
conv_w = mge.Parameter(np.random.randn(8,3,3,3).astype(np.float32))
conv_bias = mge.Parameter(np.zeros((1, 8, 1, 1), dtype=np.float32))
x = F.conv2d(x, conv_w, conv_bias)
print(x.shape)
x = F.relu(x)
conv_w = mge.Parameter(np.random.randn(16, 8, 3, 3).astype(np.float32))
conv_bias = mge.Parameter(np.zeros((1, 16, 1, 1), dtype=np.float32))
x = F.conv2d(x, conv_w, conv_bias)
print(x.shape)
x = F.relu(x)
print(x.shape)
return x

x = mge.tensor(np.random.randn(2, 3, 32, 32).astype(np.float32))
out = two_layer_conv(x)
print(out.shape)

def generate_random_exp(n=100, noise=5):
w = np.random.randint(5, 10)
b = np.random.randint(-10, 10)
print(“w:{}, b:{}”.format(w, b))

data = np.zeros((n,))
label = np.zeros((n,))

for i in range(n):
    data[i] = np.random.uniform(-10, 10)
    label[i] = w * data[i] + b + np.random.uniform(-noise, noise)
    plt.scatter(data[i], label[i], marker=".")

plt.plot()
plt.show()
return data, label

ori_data, ori_label = generate_random_exp()

epochs = 10
lr = 0.01

data = mge.tensor(ori_data)
label = mge.tensor(ori_label)

w = mge.Parameter([0.0])
b = mge.Parameter([0.0])

def linear_model(x):
return w * x + b

gm = GradManager().attach([w, b])
optimizer = optim.SGD([w, b], lr=lr)

for epoch in range(epochs):
with gm:
pred = linear_model(data)
loss = F.loss.square_loss(pred, label)
gm.backward(loss)
optimizer.step().clear_grad()
print(“epoch={}, w={:.3f}, b={:.3f}, loss={:.3f}”.format(epoch, w.item(), b.item(), loss.item()))

x = np.array([-10, 10])
y = w.numpy() * x + b.numpy()
plt.scatter(data, label, marker=".")
plt.plot(x,y,"-b")
plt.show()

from megengine.data.dataset import MNIST
import megengine.module as M
import megengine.functional as F
import megengine as mge
import numpy as np
from megengine import optimizer
from megengine.autodiff import GradManager
from megengine.data import SequentialSampler, RandomSampler, DataLoader
from megengine.jit import trace
from megengine.data.transform import RandomResizedCrop, Normalize, ToMode, Pad, Compose

class LeNet(M.Module):
def init(self):
super().init()
self.conv1 = M.Conv2d(1, 6, kernel_size=5, bias=False)
self.relu1 = M.ReLU()
self.pool1 = M.MaxPool2d(2, 2)
self.conv2 = M.Conv2d(6, 16, kernel_size=5, bias=False)
self.relu2 = M.ReLU()
self.pool2 = M.MaxPool2d(2, 2)
# 两层全连接 + ReLU
self.fc1 = M.Linear(16 * 5 * 5, 120)
self.relu3 = M.ReLU()
self.fc2 = M.Linear(120, 84)
self.relu4 = M.ReLU()
# 分类器
self.classifier = M.Linear(84, 10)

def forward(self, x):
    x = self.pool1(self.relu1(self.conv1(x)))
    x = self.pool2(self.relu2(self.conv2(x)))
    # F.flatten 将原本形状为 (N, C, H, W) 的张量x从第一个维度（即C）开始拉平成一个维度，
    # 得到的新张量形状为 (N, C*H*W) 。 等价于 reshape 操作： x = x.reshape(x.shape[0], -1)
    x = F.flatten(x, 1)
    x = self.relu3(self.fc1(x))
    x = self.relu4(self.fc2(x))
    x = self.classifier(x)
    return x

从 MegEngine 中导入 MNIST 数据集

def pre_data_processing(mode):
“”"
根据不同的模式生成数据
:param mode: train or test
:return:
“”"
is_train = mode == ‘train’

mnist_dataset = MNIST(root="./dataset/MNIST", train=is_train, download=False)

dataloader = DataLoader(
    mnist_dataset,
    transform=Compose([
        Normalize(mean=0.1307 * 255, std=0.3081 * 255),
        Pad(2),
        ToMode('CHW'),
    ]),
    sampler=RandomSampler(dataset=mnist_dataset, batch_size=64, drop_last=True),
    # 训练时一般使用RandomSampler来打乱数据顺序
)
return dataloader

def train():
train_dataloader = pre_data_processing(‘train’)

epochs = 15

le_net = LeNet()
gm = GradManager().attach(list(le_net.parameters()))

for epoch in range(epochs):
    if epoch < 5:
        lr = 0.05
    elif epoch < 10:
        lr = 0.02
    else:
        lr = 0.01
    opt = optimizer.SGD(le_net.parameters(), lr=lr)

    total_loss = 0
    for step, (batch_data, batch_label) in enumerate(train_dataloader):
        with gm:
            logits = le_net(batch_data)
            # logits 为网络的输出结果，label 是数据的真实标签即训练目标
            loss = F.loss.cross_entropy(logits, batch_label)  # 交叉熵损失函数
            gm.backward(loss)
        opt.step().clear_grad()
        total_loss += loss.numpy().item()
    print("epoch: {}, loss {}".format(epoch, total_loss / len(train_dataloader)))

mge.save(le_net.state_dict(), "./lenet.mge")

return './lenet.mge'

def test(net):
test_dataloader = pre_data_processing(‘test’)
le_net = LeNet()
le_net.load_state_dict(mge.load(net))
le_net.eval() # 设置为测试模式
correct = 0
total = 0
for idx, (batch_data, batch_label) in enumerate(test_dataloader):
logits = le_net(batch_data)
predicted = logits.numpy().argmax(axis=1)
correct += (predicted == batch_label).sum()
total += batch_label.shape[0]
print(“correct: {}, total: {}, accuracy: {}”.format(correct, total, float(correct) / total))

image840×476 6 KB

本地跑通

image1200×939 112 KB

本地跑通

1. img crop resize (与gt iou小于0.2的划为负样本)
   
   

   image941×789 67.9 KB
   
   2.划分数据集
   
   

   image1261×617 78.2 KB
   
   3.train
   
   

   image1413×962 98.5 KB

程序



统计结果：

mean_h: 32,mean_w: 32
max_h: 32,max_w: 32
min_h: 32,min_w: 32

此本文本将被隐藏