HCIA-Cloud Service V3.0职业认证训练营是一个超级好的活动，非常感谢华为云提供的这次学习机会！同事发给我这个活动的时候半信半疑，抱着近距离体验云计算服务的想法，报名，入群，学习，打卡，实验，考试，积极参与了进来，整体感觉很不错，活动目标明确，内容充实且有趣味，课程讲解清晰并细致，实验设计精心且步骤详细。HCIA-Cloud Service认证定位于培养与认证掌握公有云最前沿知识技能，能够熟练使用华为云服务产品的工程师。面向有认证需求的在校大学生、云计算初学者、开发者、云服务工程师等人员群体及相关华为云伙伴；通过HCIA-Cloud Service认证，将证明系统学习过，华为云服务架构和生态，华为云计算服务、存储服务、网络服务、安全服务、管理与监控、关系型数据库、CDN&云视频服务和创新应用服务的管理和应用，具备使用各类云服务产品进行应用部署和维护的能力，可以助力企业实现ICT环境的云转型。

    老师讲课讲得很好，之前只是使用过华为云的产品，但不是很了解，通过参加这次HCIA职业认证训练营的学习，对华为云的产品有了全面和深入的了解。    从这次活动详细了解到计算云服务中对弹性云服务器，裸金属服务器和云容器引擎服务等概念和它们的特性及应用场景。在网络云服务学习到VPC，EIP，ELB，VPN，NAT和DNS的区别和应用场景。针对云硬盘EVS，对象存储OBS和弹性文件SFS也有详细的介绍，为以后使用提供方便。同时还介绍关系型数据库和文档数据库DDS，对云上安全的要求，内容分发网络CDN和EI企业智能类服务。最后针对运维人员提供运维基础，使得运维人员能通过云监控，云日志和云审计等服务来更好的管理和维护好云上资源。    这次活动通过动手做沙箱实验和考微认证，还有结营考试来巩固学习云服务知识。希望通过这次活动能抽中考试劵，这样通过再次考试，更能加深对云服务的学习。

首先，在谈及此次活动心得体会之前，我想在此表达我的谢意，非常感谢此次活动的主办方：华为云官方。与此同时，对于活动中辛勤工作的老师和同学们致以诚挚的谢意。大学生职业素质：是大学生毕业后作为劳动者对社会职业了解与适应能力的一种综合体现，其主要表现在：职业兴趣、职业能力、职业个性、职业情况、职业态度等方面。 随着就业形式的日益严峻，大学生就业成为社会关注的热点问题，一方面，大学生就业困难，另一方面，企业招聘不到合格的人才，提高大学生的职业素质，已经成为提高大学生就业竞争力的重要手段。对任何企业和个人来说。职业素质的意义都十分重要。一个人，要是缺乏良好的职业素质，那么他就不可能取得什么突出的业绩；而一个企业，要是没有一支职业素质过硬的员工队伍，就不可能在激烈的市场竞争中占有一席之地。大学生个人职业素质水平在很大程度上决定着自己是否能被认可，直接影响到今后职业生涯的发展，随着中国经济的高速发展，企业对高素质人才的需求越来越高，对大学生的职业素质也提出更高的要求。培养大学生的职业素质对大学生的就业以及对整个社会都有重要的作用。千呼万唤始出来，大学生职业素质和就业能力训练营与我们相逢，从初始的相逢，到现在的相知。在这个过程中，每一个参加训练营的同学都收获了属于自己的成功和喜悦。“HCIA-Cloud Service V3.0职业认证训练营“在训练营开幕活动中，大家展示了当代大学生的时代创新精神，以各种独特的视角阐释了团队精神，是的，职场中团队合作能力是我们不可缺失的，良好的沟通、协作便是你融入团队必不可少的工具。通过第一站活动提高了参与者的职业素质以及团队协作的能力，从而帮助大家在以后的职场生涯中找到适合自己的位置，最终成长为一名合格的职场领导者。

该autograd包提供自动求导为上张量的所有操作。它是一个按运行定义的框架，这意味着您的反向传播是由您的代码运行方式定义的，并且每次迭代都可以不同。torch.autograd.function （函数的反向传播）torch.autograd.functional （计算图的反向传播）torch.autograd.gradcheck （数值梯度检查）torch.autograd.anomaly_mode （在自动求导时检测错误产生路径）torch.autograd.grad_mode （设置是否需要梯度）model.eval() 与 torch.no_grad()torch.autograd.profiler （提供 function 级别的统计信息）「下面使用 Autograd 进行反向传播。」如果requires_grad=True，则 Tensor 对象会跟踪它是如何创建的。x = torch.tensor([1., 2., 3.], requires_grad = True) print('x: ', x) y = torch.tensor([10., 20., 30.], requires_grad = True) print('y: ', y) z = x + y print('\nz = x + y') print('z:', z) x: tensor([1., 2., 3.], requires_grad=True) y: tensor([10., 20., 30.], requires_grad=True) z = x + y z: tensor([11., 22., 33.], grad_fn=<AddBackward0>)因为requires_grad=True，z知道它是通过增加两个张量的产生z = x + y。s = z.sum() print(s) tensor(66., grad_fn=<SumBackward0>)s是由它的数字总和创建的。当我们调用.backward()，反向传播从s开始运行。然后可以计算梯度。s.backward() print('x.grad: ', x.grad) print('y.grad: ', y.grad) x.grad: tensor([1., 1., 1.]) y.grad: tensor([1., 1., 1.])下面例子是计算log(x)的导数为1 / ximport torch x = torch.tensor([0.5, 0.75], requires_grad=True) # 1 / x y = torch.log(x[0] * x[1]) y.backward() x.grad # tensor([2.0000, 1.3333])

验证码是根据随机字符生成一幅图片，然后在图片中加入干扰象素，用户必须手动填入，防止有人利用机器人自动批量注册、灌水、发垃圾广告等等 。数据集来源：https://www.kaggle.com/fournierp/captcha-version-2-images图片是5个字母的单词，可以包含数字。这些图像应用了噪声（模糊和一条线）。它们是200 x 50 PNG。我们的任务是尝试制作光学字符识别算法的模型。在数据集中存在的验证码png图片，对应的标签就是图片的名字import os import numpy as np import pandas as pd import cv2 import matplotlib.pyplot as plt import seaborn as sns # imgaug 图片数据增强 import imgaug.augmenters as iaa import tensorflow as tf # Conv2D MaxPooling2D Dropout Flatten Dense BN GAP from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense, Layer, BatchNormalization, GlobalAveragePooling2D from tensorflow.keras.optimizers import Adam from tensorflow.keras import Model, Input from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau # 图片处理器 from tensorflow.keras.preprocessing.image import ImageDataGenerator import plotly.express as px import plotly.graph_objects as go import plotly.offline as pyo pyo.init_notebook_mode()对数据进行一个简单的分析，统计图像中大约出现了什么样的符号。# 数据路径 DIR = '../input/captcha-version-2-images/samples/samples' # 存储验证码的标签 captcha_list = [] characters = {} for captcha in os.listdir(DIR): captcha_list.append(captcha) # 每张验证码的captcha_code captcha_code = captcha.split(".")[0] for i in captcha_code: # 遍历captcha_code characters[i] = characters.get(i, 0) +1 symbols = list(characters.keys()) len_symbols = len(symbols) print(f'图像中只使用了{len_symbols}符号') plt.bar(*zip(*characters.items())) plt.title('Frequency of symbols') plt.show()如何提取图像的数据建立X，y？？# 如何提取图像 建立 model X 的shape 1070 * 50 * 200 * 1 # y的shape 5 * 1070 * 19 for i, captcha in enumerate(captcha_list): captcha_code = captcha.split('.')[0] # cv2.IMREAD_GRAYSCALE 灰度图 captcha_cv2 = cv2.imread(os.path.join(DIR, captcha),cv2.IMREAD_GRAYSCALE) # 缩放 captcha_cv2 = captcha_cv2 / 255.0 # print(captcha_cv2.shape) (50, 200) # 将captcha_cv2的(50, 200) 切换成(50, 200, 1) captcha_cv2 = np.reshape(captcha_cv2, img_shape) # (5,19) targs = np.zeros((len_captcha, len_symbols)) for a, b in enumerate(captcha_code): targs[a, symbols.index(b)] = 1 X[i] = captcha_cv2 y[:, i] = targs print("shape of X:", X.shape) print("shape of y:", y.shape)输出如下print("shape of X:", X.shape) print("shape of y:", y.shape)通过Numpy中random 随机选择数据，划分训练集和测试集# 生成随机数 from numpy.random import default_rng rng = default_rng(seed=1) test_numbers = rng.choice(1070, size=int(1070*0.3), replace=False) X_test = X[test_numbers] X_full = np.delete(X, test_numbers,0) y_test = y[:,test_numbers] y_full = np.delete(y, test_numbers,1) val_numbers = rng.choice(int(1070*0.7), size=int(1070*0.3), replace=False) X_val = X_full[val_numbers] X_train = np.delete(X_full, val_numbers,0) y_val = y_full[:,val_numbers] y_train = np.delete(y_full, val_numbers,1)在此验证码数据中，容易出现过拟合的现象，你可能会想到添加更多的新数据、 添加正则项等， 但这里使用数据增强的方法，特别是对于机器视觉的任务，数据增强技术尤为重要。常用的数据增强操作：imgaug库。imgaug是提供了各种图像增强操作的python库 https://github.com/aleju/imgaug。imgaug几乎包含了所有主流的数据增强的图像处理操作， 增强方法详见github# Sequential(C, R) 尺寸增加了5倍， # 选取一系列子增强器C作用于每张图片的位置,第二个参数表示是否对每个batch的图片应用不同顺序的Augmenter list # rotate=(-8, 8) 旋转 # iaa.CropAndPad 截取(crop)或者填充(pad),填充时,被填充区域为黑色。 # px: 想要crop(negative values)的或者pad(positive values)的像素点。 # (top, right, bottom, left) # 当pad_mode=constant的时候选择填充的值 aug =iaa.Sequential([iaa.CropAndPad( px=((0, 10), (0, 35), (0, 10), (0, 35)), pad_mode=['edge'], pad_cval=1 ),iaa.Rotate(rotate=(-8,8))]) X_aug_train = None y_aug_train = y_train for i in range(40): X_aug = aug(images = X_train) if X_aug_train is not None: X_aug_train = np.concatenate([X_aug_train, X_aug], axis = 0) y_aug_train = np.concatenate([y_aug_train, y_train], axis = 1) else: X_aug_train = X_aug让我们看看一些数据增强的训练图像。fig, ax = plt.subplots(nrows=2, ncols =5, figsize = (16,16)) for i in range(10): index = np.random.randint(X_aug_train.shape[0]) ax[i//5][i%5].imshow(X_aug_train[index],cmap='gray')这次使用函数式API创建模型，函数式API是创建模型的另一种方式，它具有更多的灵活性，包括创建更为复杂的模型。需要定义inputs和outputs#函数式API模型创建 captcha = Input(shape=(50,200,channels)) x = Conv2D(32, (5,5),padding='valid',activation='relu')(captcha) x = MaxPooling2D((2,2),padding='same')(x) x = Conv2D(64, (3,3),padding='same',activation='relu')(x) x = MaxPooling2D((2,2),padding='same')(x) x = Conv2D(128, (3,3),padding='same',activation='relu')(x) maxpool = MaxPooling2D((2,2),padding='same')(x) outputs = [] for i in range(5): x = Conv2D(256, (3,3),padding='same',activation='relu')(maxpool) x = MaxPooling2D((2,2),padding='same')(x) x = Flatten()(x) x = Dropout(0.5)(x) x = BatchNormalization()(x) x = Dense(64, activation='relu')(x) x = Dropout(0.5)(x) x = BatchNormalization()(x) x = Dense(len_symbols , activation='softmax' , name=f'char_{i+1}')(x) outputs.append(x) model = Model(inputs = captcha , outputs=outputs) # ReduceLROnPlateau更新学习率 reduce_lr = ReduceLROnPlateau(patience =3, factor = 0.5,verbose = 1) model.compile(loss='categorical_crossentropy', optimizer=Adam(learning_rate=0.0005), metrics=["accuracy"]) # EarlyStopping用于提前停止训练的callbacks。具体地,可以达到当训练集上的loss不在减小 earlystopping = EarlyStopping(monitor ="val_loss", mode ="min", patience = 10, min_delta = 1e-4, restore_best_weights = True) history = model.fit(X_train, [y_train[i] for i in range(5)], batch_size=32, epochs=30, verbose=1, validation_data = (X_val, [y_val[i] for i in range(5)]), callbacks =[earlystopping,reduce_lr])下面对model进行一个测试和评估。score = model.evaluate(X_test,[y_test[0], y_test[1], y_test[2], y_test[3], y_test[4]],verbose=1) metrics = ['loss','char_1_loss', 'char_2_loss', 'char_3_loss', 'char_4_loss', 'char_5_loss', 'char_1_acc', 'char_2_acc', 'char_3_acc', 'char_4_acc', 'char_5_acc'] for i,j in zip(metrics, score): print(f'{i}: {j}')具体输出如下：11/11 [==============================] - 0s 11ms/step - loss: 0.7246 - char_1_loss: 0.0682 - char_2_loss: 0.1066 - char_3_loss: 0.2730 - char_4_loss: 0.2636 - char_5_loss: 0.0132 - char_1_accuracy: 0.9844 - char_2_accuracy: 0.9657 - char_3_accuracy: 0.9408 - char_4_accuracy: 0.9626 - char_5_accuracy: 0.9938 loss: 0.7246273756027222 char_1_loss: 0.06818050146102905 char_2_loss: 0.10664034634828568 char_3_loss: 0.27299806475639343 char_4_loss: 0.26359987258911133 char_5_loss: 0.013208594173192978 char_1_acc: 0.9844236969947815 char_2_acc: 0.9657320976257324 char_3_acc: 0.940809965133667 char_4_acc: 0.9626168012619019 char_5_acc: 0.9937694668769836字母1到字母5的精确值都大于绘制loss和scoremetrics_df = pd.DataFrame(history.history) columns = [col for col in metrics_df.columns if 'loss' in col and len(col)>8] fig = px.line(metrics_df, y = columns) fig.show()plt.figure(figsize=(15,8)) plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'val'], loc='upper right',prop={'size': 10}) plt.show()# 预测数据 def predict(captcha): captcha = np.reshape(captcha , (1, 50,200,channels)) result = model.predict(captcha) result = np.reshape(result ,(5,len_symbols)) # 取出最大预测中的输出 label = ''.join([symbols[np.argmax(i)] for i in result]) return label predict(X_test[2]) # 25277下面预测所有的数据actual_pred = [] for i in range(X_test.shape[0]): actual = ''.join([symbols[i] for i in (np.argmax(y_test[:, i],axis=1))]) pred = predict(X_test[i]) actual_pred.append((actual, pred)) print(actal_pred[:10])输出如下[('n4b4m', 'n4b4m'), ('42nxy', '42nxy'), ('25257', '25277'), ('cewnm', 'cewnm'), ('w46ep', 'w46ep'), ('cdcb3', 'edcb3'), ('8gf7n', '8gf7n'), ('nny5e', 'nny5e'), ('gm2c2', 'gm2c2'), ('g7fmc', 'g7fmc')]sameCount = 0 diffCount = 0 letterDiff = {i:0 for i in range(5)} incorrectness = {i:0 for i in range(1,6)} for real, pred in actual_pred: # 预测和输出相同 if real == pred: sameCount += 1 else: # 失败 diffCount += 1 # 遍历 incorrectnessPoint = 0 for i in range(5): if real[i] != pred[i]: letterDiff[i] += 1 incorrectnessPoint += 1 incorrectness[incorrectnessPoint] += 1 x = ['True predicted', 'False predicted'] y = [sameCount, diffCount] fig = go.Figure(data=[go.Bar(x = x, y = y)]) fig.show()在预测数据中，一共有287个数据预测正确。在这里，我们可以看到出现错误到底是哪一个index。x1 = ["Character " + str(x) for x in range(1, 6)] fig = go.Figure(data=[go.Bar(x = x1, y = list(letterDiff.values()))]) fig.show()为了计算每个单词的错误数，绘制相关的条形图。x2 = [str(x) + " incorrect" for x in incorrectness.keys()] y2 = list(incorrectness.values()) fig = go.Figure(data=[go.Bar(x = x2, y = y2)]) fig.show()下面绘制错误的验证码图像，并标准正确和错误的区别。fig, ax = plt.subplots(nrows = 8, ncols=4,figsize = (16,20)) count = 0 for i, (actual , pred) in enumerate(actual_pred): if actual != pred: img = X_test[i] try: ax[count//4][count%4].imshow(img, cmap = 'gray') ax[count//4][count%4].title.set_text(pred + ' - ' + actual) count += 1 except: pass

非常有幸能有这次机会参加华为云HCIA-Cloud  Service职业认证训练营，收获颇多，使我对云计算这个概念更加清晰。以下是我的所获所得。云计算定义：字面理解：“云”这里指用互联网的意思，“计算”指提供一台超强计算能力的一台计算机（强大的计算、网络、存储的）；整体上看：通过互联网来获得云服务供应商所提供的云服务。云计算是一种服务模式，该模式允许用户通过网络方便的获得和释放共享资源池中的资源，而无需与服务提供商进行复杂的沟通和交互。服务模式：基础设施即服务：计算、网络、存储（Iaas）平台即服务：计算、网络、存储、操作系统、中间件&运行时（Paas）软件即服务：计算、网络、存储、操作系统、中间件&运行时应用软件、数据&信息（Saas）云的部署模型：       私有云：就是自己搭建自己用，一般用于高校与一些对数据保密要求高又想使用云技术的企业，高校一般不会租公有云，不会帮学校积累固定资产，因为高校招生需要有固定的资产来支撑教育厅的教育资源考察。       混合云：                     私有云与公有云一起使用下的云。       公有云：由云服务供应商搭建的云，并给外界提供接口，来注册公有云账号来使用云服务供应商提供的云服务。核心属性：共享资源服务，提供基础IT设施服务：特点：资源集中，服务分散，提高资源利用率，降低成本。弹性伸缩、高可靠、按需分配、服务可衡量等华为云生态       共创       共享       共赢架构       瑶光、云擎天架构云交付模式       公有云模式       华为云Stack模式       边缘云模式华为公有云平台       IAM权限管理              iam项目实现资源              分组与隔离       计算类服务              ECS弹性云服务器              BMS裸金属云服务器              IMS镜像云服务              AS伸缩服务              CCE云容器引擎       网络类服务              VPC私有网              ELC弹性负载均衡       存储类服务              EVS云磁盘              OBS对象存储                     bucket(桶)                            对象                                   key                                   data                                   metadata              SFS文件存储                     NFS(linux)                     CIFS（Window）上完训练营，感觉收获很多，我还会参加其他培训，最后祝华为云越办越好！

使用 TensorFlow (Keras API) 实现一个用于多分类任务的深度学习模型，该任务需要对阿拉伯语手写字符数据集进行识别。数据集下载地址：https://www.kaggle.com/mloey1/ahcd1数据集介绍该数据集由 60 名参与者书写的16,800 个字符组成，年龄范围在 19 至 40 岁之间，90% 的参与者是右手。每个参与者在两种形式上写下每个字符（从“alef”到“yeh”）十次，如图 7（a）和 7（b）所示。表格以 300 dpi 的分辨率扫描。使用 Matlab 2016a 自动分割每个块以确定每个块的坐标。该数据库分为两组：训练集（每类 13,440 个字符到 480 个图像）和测试集（每类 3,360 个字符到 120 个图像）。数据标签为1到28个类别。在这里，所有数据集都是CSV文件，表示图像像素值及其相应标签，并没有提供对应的图片数据。导入模块import numpy as np import pandas as pd #允许对dataframe使用display（） from IPython.display import display # 导入读取和处理图像所需的库 import csv from PIL import Image from scipy.ndimage import rotate读取数据# 训练数据images letters_training_images_file_path = "../input/ahcd1/csvTrainImages 13440x1024.csv" # 训练数据labels letters_training_labels_file_path = "../input/ahcd1/csvTrainLabel 13440x1.csv" # 测试数据images和labels letters_testing_images_file_path = "../input/ahcd1/csvTestImages 3360x1024.csv" letters_testing_labels_file_path = "../input/ahcd1/csvTestLabel 3360x1.csv" # 加载数据 training_letters_images = pd.read_csv(letters_training_images_file_path, header=None) training_letters_labels = pd.read_csv(letters_training_labels_file_path, header=None) testing_letters_images = pd.read_csv(letters_testing_images_file_path, header=None) testing_letters_labels = pd.read_csv(letters_testing_labels_file_path, header=None) print("%d个32x32像素的训练阿拉伯字母图像。" %training_letters_images.shape[0]) print("%d个32x32像素的测试阿拉伯字母图像。" %testing_letters_images.shape[0]) training_letters_images.head()13440个32x32像素的训练阿拉伯字母图像。3360个32x32像素的测试阿拉伯字母图像。查看训练数据的headnp.unique(training_letters_labels) array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], dtype=int32)下面需要将csv值转换为图像，我们希望展示对应图像的像素值图像。def convert_values_to_image(image_values, display=False): image_array = np.asarray(image_values) image_array = image_array.reshape(32,32).astype('uint8') # 原始数据集被反射，因此我们将使用np.flip翻转它，然后通过rotate旋转，以获得更好的图像。 image_array = np.flip(image_array, 0) image_array = rotate(image_array, -90) new_image = Image.fromarray(image_array) if display == True: new_image.show() return new_image convert_values_to_image(training_letters_images.loc[0], True)这是一个字母f。下面，我们将进行数据预处理，主要进行图像标准化，我们通过将图像中的每个像素除以255来重新缩放图像，标准化到[0，1]training_letters_images_scaled = training_letters_images.values.astype('float32')/255 training_letters_labels = training_letters_labels.values.astype('int32') testing_letters_images_scaled = testing_letters_images.values.astype('float32')/255 testing_letters_labels = testing_letters_labels.values.astype('int32') print("Training images of letters after scaling") print(training_letters_images_scaled.shape) training_letters_images_scaled[0:5]输出如下Training images of letters after scaling (13440, 1024)从标签csv文件我们可以看到，这是一个多类分类问题。下一步需要进行分类标签编码，建议将类别向量转换为矩阵类型。输出形式如下：将1到28，变成0到27类别。从“alef”到“yeh”的字母有0到27的分类号。to_categorical就是将类别向量转换为二进制（只有0和1）的矩阵类型表示在这里，我们将使用keras的一个热编码对这些类别值进行编码。一个热编码将整数转换为二进制矩阵，其中数组仅包含一个“1”，其余元素为“0”。from keras.utils import to_categorical # one hot encoding number_of_classes = 28 training_letters_labels_encoded = to_categorical(training_letters_labels-1, num_classes=number_of_classes) testing_letters_labels_encoded = to_categorical(testing_letters_labels-1, num_classes=number_of_classes)下面将输入图像重塑为32x32x1，因为当使用TensorFlow作为后端时，Keras CNN需要一个4D数组作为输入，并带有形状（nb_samples、行、列、通道）其中 nb_samples对应于图像（或样本）的总数，而行、列和通道分别对应于每个图像的行、列和通道的数量。# reshape input letter images to 32x32x1 training_letters_images_scaled = training_letters_images_scaled.reshape([-1, 32, 32, 1]) testing_letters_images_scaled = testing_letters_images_scaled.reshape([-1, 32, 32, 1]) print(training_letters_images_scaled.shape, training_letters_labels_encoded.shape, testing_letters_images_scaled.shape, testing_letters_labels_encoded.shape) # (13440, 32, 32, 1) (13440, 28) (3360, 32, 32, 1) (3360, 28)因此，我们将把输入图像重塑成4D张量形状（nb_samples，32，32，1），因为我们图像是32x32像素的灰度图像。#将输入字母图像重塑为32x32x1 training_letters_images_scaled = training_letters_images_scaled.reshape([-1, 32, 32, 1]) testing_letters_images_scaled = testing_letters_images_scaled.reshape([-1, 32, 32, 1]) print(training_letters_images_scaled.shape, training_letters_labels_encoded.shape, testing_letters_images_scaled.shape, testing_letters_labels_encoded.shape)设计模型结构from keras.models import Sequential from keras.layers import Conv2D, MaxPooling2D, GlobalAveragePooling2D, BatchNormalization, Dropout, Dense def create_model(optimizer='adam', kernel_initializer='he_normal', activation='relu'): # create model model = Sequential() model.add(Conv2D(filters=16, kernel_size=3, padding='same', input_shape=(32, 32, 1), kernel_initializer=kernel_initializer, activation=activation)) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.2)) model.add(Conv2D(filters=32, kernel_size=3, padding='same', kernel_initializer=kernel_initializer, activation=activation)) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.2)) model.add(Conv2D(filters=64, kernel_size=3, padding='same', kernel_initializer=kernel_initializer, activation=activation)) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.2)) model.add(Conv2D(filters=128, kernel_size=3, padding='same', kernel_initializer=kernel_initializer, activation=activation)) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=2)) model.add(Dropout(0.2)) model.add(GlobalAveragePooling2D()) #Fully connected final layer model.add(Dense(28, activation='softmax')) # Compile model model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer=optimizer) return model「模型结构」第一隐藏层是卷积层。该层有16个特征图，大小为3×3和一个激活函数，它是relu。这是输入层，需要具有上述结构的图像。第二层是批量标准化层，它解决了特征分布在训练和测试数据中的变化，BN层添加在激活函数前，对输入激活函数的输入进行归一化。这样解决了输入数据发生偏移和增大的影响。第三层是MaxPooling层。最大池层用于对输入进行下采样，使模型能够对特征进行假设，从而减少过拟合。它还减少了参数的学习次数，减少了训练时间。下一层是使用dropout的正则化层。它被配置为随机排除层中20%的神经元，以减少过度拟合。另一个隐藏层包含32个要素，大小为3×3和relu激活功能，从图像中捕捉更多特征。其他隐藏层包含64和128个要素，大小为3×3和一个relu激活功能，重复三次卷积层、MaxPooling、批处理规范化、正则化和* GlobalAveragePooling2D层。最后一层是具有（输出类数）的输出层，它使用softmax激活函数，因为我们有多个类。每个神经元将给出该类的概率。使用分类交叉熵作为损失函数，因为它是一个多类分类问题。使用精确度作为衡量标准来提高神经网络的性能。model = create_model(optimizer='Adam', kernel_initializer='uniform', activation='relu') model.summary()「Keras支持在Keras.utils.vis_utils模块中绘制模型，该模块提供了使用graphviz绘制Keras模型的实用函数」import pydot from keras.utils import plot_model plot_model(model, to_file="model.png", show_shapes=True) from IPython.display import Image as IPythonImage display(IPythonImage('model.png'))训练模型，使用batch_size=20来训练模型，对模型进行15个epochs阶段的训练。训练结果如下所示：最后Epochs绘制损耗和精度曲线。import matplotlib.pyplot as plt def plot_loss_accuracy(history): # Loss plt.figure(figsize=[8,6]) plt.plot(history.history['loss'],'r',linewidth=3.0) plt.plot(history.history['val_loss'],'b',linewidth=3.0) plt.legend(['Training loss', 'Validation Loss'],fontsize=18) plt.xlabel('Epochs ',fontsize=16) plt.ylabel('Loss',fontsize=16) plt.title('Loss Curves',fontsize=16) # Accuracy plt.figure(figsize=[8,6]) plt.plot(history.history['accuracy'],'r',linewidth=3.0) plt.plot(history.history['val_accuracy'],'b',linewidth=3.0) plt.legend(['Training Accuracy', 'Validation Accuracy'],fontsize=18) plt.xlabel('Epochs ',fontsize=16) plt.ylabel('Accuracy',fontsize=16) plt.title('Accuracy Curves',fontsize=16) plot_loss_accuracy(history)「加载具有最佳验证损失的模型」# 加载具有最佳验证损失的模型 model.load_weights('weights.hdf5') metrics = model.evaluate(testing_letters_images_scaled, testing_letters_labels_encoded, verbose=1) print("Test Accuracy: {}".format(metrics[1])) print("Test Loss: {}".format(metrics[0]))输出如下：3360/3360 [==============================] - 0s 87us/step Test Accuracy: 0.9678571224212646 Test Loss: 0.11759862171020359打印混淆矩阵。from sklearn.metrics import classification_report def get_predicted_classes(model, data, labels=None): image_predictions = model.predict(data) predicted_classes = np.argmax(image_predictions, axis=1) true_classes = np.argmax(labels, axis=1) return predicted_classes, true_classes, image_predictions def get_classification_report(y_true, y_pred): print(classification_report(y_true, y_pred)) y_pred, y_true, image_predictions = get_predicted_classes(model, testing_letters_images_scaled, testing_letters_labels_encoded) get_classification_report(y_true, y_pred)输出如下： precision recall f1-score support 0 1.00 0.98 0.99 120 1 1.00 0.98 0.99 120 2 0.80 0.98 0.88 120 3 0.98 0.88 0.93 120 4 0.99 0.97 0.98 120 5 0.92 0.99 0.96 120 6 0.94 0.97 0.95 120 7 0.94 0.95 0.95 120 8 0.96 0.88 0.92 120 9 0.90 1.00 0.94 120 10 0.94 0.90 0.92 120 11 0.98 1.00 0.99 120 12 0.99 0.98 0.99 120 13 0.96 0.97 0.97 120 14 1.00 0.93 0.97 120 15 0.94 0.99 0.97 120 16 1.00 0.93 0.96 120 17 0.97 0.97 0.97 120 18 1.00 0.93 0.96 120 19 0.92 0.95 0.93 120 20 0.97 0.93 0.94 120 21 0.99 0.96 0.97 120 22 0.99 0.98 0.99 120 23 0.98 0.99 0.99 120 24 0.95 0.88 0.91 120 25 0.94 0.98 0.96 120 26 0.95 0.97 0.96 120 27 0.98 0.99 0.99 120 accuracy 0.96 3360 macro avg 0.96 0.96 0.96 3360 weighted avg 0.96 0.96 0.96 3360最后绘制随机几个相关预测的图片indices = np.random.randint(0, testing_letters_labels.shape[0], size=49) y_pred = np.argmax(model.predict(training_letters_images_scaled), axis=1) for i, idx in enumerate(indices): plt.subplot(7,7,i+1) image_array = training_letters_images_scaled[idx][:,:,0] image_array = np.flip(image_array, 0) image_array = rotate(image_array, -90) plt.imshow(image_array, cmap='gray') plt.title("Pred: {} - Label: {}".format(y_pred[idx], (training_letters_labels[idx] -1))) plt.xticks([]) plt.yticks([]) plt.show()

使用 TensorFlow (Keras API) 实现一个用于二进制分类任务的深度学习模型，该任务包括将细胞的图像标记为感染或未感染疟疾。数据集来源：https://www.kaggle.com/iarunava/cell-images-for-detecting-malaria数据集包含2个文件夹感染：:13780张图片未感染：13780张图片总共27558张图片。此数据集取自NIH官方网站：https://ceb.nlm.nih.gov/repositories/malaria-datasets/环境：kaggle，天池实验室或者gogole colab都可以。导入相关模块import cv2 import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Flatten, Activation from sklearn.model_selection import train_test_split import numpy as np import matplotlib.pyplot as plt import glob import os对于图片数据存在形状不一样的情况，因此需要使用 OpenCV 进行图像预处理。将图片变成 numpy 数组（数字格式）的形式转换为灰度，并将其调整为一个(70x70)形状。img_dir="../input/cell-images-for-detecting-malaria/cell_images" img_size=70 def load_img_data(path): # 打乱数据 image_files = glob.glob(os.path.join(path, "Parasitized/*.png")) + \ glob.glob(os.path.join(path, "Uninfected/*.png")) X, y = [], [] for image_file in image_files: # 命名标签 0 for uninfected and 1 for infected label = 0 if "Uninfected" in image_file else 1 # load the image in gray scale 变成灰度图片 img_arr = cv2.imread(image_file, cv2.IMREAD_GRAYSCALE) # resize the image to (70x70) 调整图片大小 img_resized = cv2.resize(img_arr, (img_size, img_size)) X.append(img_resized) y.append(label) return X, y X, y = load_img_data(img_dir)查看X的shape。print(X.shape)X的shape为(27558, 70, 70, 1)，27558表示图片的数据，70*70表示图片的长和宽像素。另外，为了帮助网络更快收敛，我们应该进行数据归一化。在sklearn 中有一些缩放方法，例如：在这里我们将除以255，因为像素可以达到的最大值是255，这将导致应用缩放后像素范围在 0 和 1 之间。X, y = load_img_data(img_dir) # reshape to (n_samples, 70, 70, 1) (to fit the NN) X = np.array(X).reshape(-1, img_size, img_size, 1) #从[0，255]到[0，1]缩放像素 帮助神经网络更快地训练 X = X / 255 # shuffle & split the dataset X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, stratify=y) print("Total training samples:", X_train.shape) print("Total validation samples:", X_test.shape[0])使用sklearn的train_test_split()方法将数据集划分为训练集和测试集，我们使用总数据的 10% 稍后对其进行验证。在建立的模型中，我们将添加 3 个卷积层，然后Flatten是由层组成的全连接Dense层。model = Sequential() model.add(Conv2D(64, (3, 3), input_shape=X_train.shape[1:])) model.add(Activation("relu")) model.add(MaxPool2D(pool_size=(2, 2))) model.add(Conv2D(64, (3, 3))) model.add(Activation("relu")) model.add(MaxPool2D(pool_size=(2, 2))) model.add(Conv2D(64, (3, 3))) model.add(Activation("relu")) model.add(MaxPool2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(64)) model.add(Activation("relu")) model.add(Dense(64)) model.add(Activation("relu")) model.add(Dense(1)) model.add(Activation("sigmoid")) model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"]) print(model.summary())由于输出是二进制的（感染或未感染），我们使用Sigmoid 函数作为输出层的激活函数。# train the model with 10 epochs, 64 batch size model.fit(X_train, np.array(y_train), batch_size=64, epochs=10, validation_split=0.2)在训练数据集及其验证拆分上实现了94%的准确率。现在使用evaluate()  来评估测试数据集上的模型loss, accuracy = model.evaluate(X_test, np.array(y_test), verbose=0) print(f"Testing on {len(X_test)} images, the results are\n Accuracy: {accuracy} | Loss: {loss}")输出如下Testing on 2756 images, the results are Accuracy: 0.9404934644699097 | Loss: 0.1666732281446457该模型在测试数据中也表现OK，准确率达到94%最后，我们将通过保存我们的模型来结束所有这个过程。model.save("model.h5")

本文是FAIR的何恺明团队关于ViT在COCO检测任务上的迁移学习性能研究。它以Mask R-CNN作为基线框架，以ViT作为骨干网络，探索了不同初始化策略对于模型性能的影响。实验表明：masking机制的无监督学习机制(如MAE、BEiT)首次在COCO检测任务迁移学习中取得了令人信服的性能提升 。论文链接：https://arxiv.org/abs/2111.11429本文是FAIR的何恺明团队关于ViT在COCO检测任务上的迁移学习性能研究。它以Mask R-CNN作为基线框架，以ViT作为骨干网络，探索了不同初始化策略对于模型性能的影响；与此同时，为尽可能保证对比的公平性，还对不同超参数进行了大量的实验；此外，为将ViT作为多尺度模式，参考XCiT对ViT不同部分的特征进行尺度调整以达成多尺度特征输出；为使得ViT模型能处理大分辨率图像，还对ViT的架构进行了改进，引入了全局与局部自注意力机制，进一步提升了模型性能取得了更佳的均衡。该文的一系列实验表明：masking机制的无监督学习机制(如MAE、BEiT)首次在COCO检测任务迁移学习中取得了令人信服的性能提升 。Abstract为测试预训练模型能否带来性能增益(准确率提升或者训练速度提升)，目标检测是一个常用的且非常重要的下游任务。面对新的ViT模型时，目标检测的复杂性使得该基线变得尤为重要(non-trivial )。然而架构不一致、缓慢训练、高内存占用以及未知训练机制等困难阻碍了标准ViT在目标检测任务上的迁移学习。本文提出了训练技术以克服上述挑战，并采用标准ViT作为Mask R-CNN的骨干。这些工具构成了本文的主要目标：我们比较了五种ViT初始化，包含SOTA自监督学习方法、监督初始化、强随机初始化基线。结果表明：近期提出的Masking无监督学习方法首次提供令人信服的迁移学习性能改善 。相比监督与其他自监督预训练方法，它可以提升 指标高达4% ；此外masking初始化具有更好的扩展性，能够随模型尺寸提升进一步提升其性能。Method因其在目标检测与迁移学习领域的无处不在性，我们采用Mask R-CNN作为基线方案。该选择也旨在对简洁性与复杂性进行均衡，同时提供具有竞争力(也许并非SOTA)的结果。相比原始版本，我们为Mask R-CNN提供了不同的改进模块与训练方案。ViT Backbone接下来，我们将解决如下两个ViT作为Mask R-CNN骨干的技术障碍如何与FPN适配；如何降低内存占用与推理耗时。FPN Compatibility  Mask R-CNN可以与输出单尺度特征的骨干，也可与输出多尺度特征(多尺度特征将被送入FPN处理)的骨干协同工作。由于FPN能够提供更好的检测结果，故我们采用了FPN方案。然而，采用FPN存在这样一个问题：ViT仅输出单尺度特征，而非CNN的多尺度特征 。为解决该问题，我们采用了XCiT中的技术对ViT中间特征进行上/下采样以提供四种不同分辨率的特征(可参见上面图示绿框部分)。第一个模块采用两个stride=2的转置卷积进行4倍上采样；第二个模块采用一个stride=2的转置卷积进行2倍上采样；第三个模块不做任何处理；最后一个模块采用stride=2的MaxPool进行下采样。假设块尺寸为16，这些模块将输出stride分别为4、8、16、32的特征并被送入到FPN中。注：Swin与MViT通过修改VIT架构解决了ViT无法输出多尺度特征的问题。这种处理方式也是一个重要的研究方向，但它与ViT的简单设计相悖，会阻碍新的无监督学习(如MAE)探索。因此，本文仅聚焦于上述生成多尺度特征的改动方式。Reducing Memory and Time Complexity  采用ViT作为Mask R-CNN的骨干会导致内存与耗时挑战。ViT中的每个自注意力操作会占用空间。在预训练过程中，该复杂度是可控的()。而在目标检测中，标准图像尺寸为，这就需要近21倍多的像素和图像块，这种高分辨率用于检测小目标。由于自注意力的复杂度，哪怕基线ViT-B也需要占用20-30G GPU显存(batch=1，FP16) 。为降低空间与时间复杂度，我们采用Windowed Self-attention，即局部自注意力，而非全局自注意力。我们将图像块拆分为非重叠窗口并在每个窗口独立计算自注意力。这种处理方式可以大幅降低空间复杂度与时间复杂度，我们默认设置。Windowed Self-attention的一个缺陷在于：骨干不能跨窗口聚合信息。针对此，我们每 隔模块添加一个全局自注意力模块 。Upgraded Modules相比原始Mask R-CNN，我们对其内置模块进行了如下改动：FPN中的卷积后接BN；RPN中采用两个卷积，而非一个卷积；RoI分类与Box回归头采用四个卷积(带BN)并后接一个全连接，而非原始的两层MLP(无BN)；Mask头中的卷积后接BNTraining Formula相比原始训练机制，我们采用了从头开始训练+更长训练周期的训练机制(如400epoch)。我们希望让超参尽可能的少，同时抵制采用额外的数据增广与正则技术。然而，我们发现：DropPath对于ViT骨干非常有效(性能提升达2)，故我们采用了该技术。总而言之，训练机制如下：LSJ数据增广(分辨率，尺度范围[0.1,2.0])；AdamW+Cosine学习率衰减+linear warmupDropPath正则技术；batch=64，混合精度训练。当采用预训练初始时，微调100epoch；当从头开始训练时，训练400epoch。Hyperparameter Tuning Protocol为使上述训练机制适用于同模型，我对学习率lr、权值wd衰减以及drop path rate三个超参进行微调，同时保持其他不变。我们采用ViT-B+MoCoV3进行了大量实验以估计合理的超参范围，基于所得估计我们构建了如下调节机制：对每个初始化，我们固定dp=0.0，对lr与wd采用grid搜索，固定搜索中心为，以此为中心搜索；对于ViT-B，我们从中选择dp(预训练参数时，训练50epoch；从头开始时，则训练100epoch)，dp=0.1为最优选择；对于ViT-L，我们采用了ViT-B的最后lr与wd，并发现dp=0.3是最佳选择。注：在训练与推理过程中，图像将padding到尺寸。Initialization Methods在骨干初始化方面，我们比较了以下五种：Random：即所有参数均随机初始化，无预训练；Supervised：即ViT骨干在ImageNet上通过监督方式预训练，分别为300和200epoch；MoCoV3：即在ImageNet上采用无监督方式预训练ViT-B与ViT-L，300epoch；BEiT：即采用BEiT方式对ViT-B与ViT-L预训练，800epoch；MAE：即采用MAE对ViT-B与ViT-L预训练，1600eoch；Nuisance Factors in Pre-training尽管我们尽可能进行公平比较，但仍存一些“令人讨厌”的不公因子：不同的预训练方法采用了不同的epoch；BEiT采用可学习相对位置偏置，而非其他方法中的绝对位置嵌入；BEiT在预训练过程中采用了layer scale，而其他方法没采用；我们尝试对与训练数据标准化，而BEiT额外采用了dVAE。Experiments&Analysis上表比较了不同初始化方案的性能，从中可以看到：无论何种初始化，采用ViT-B/L作为骨干的Mask R-CNN训练比较平滑，并无不稳定因素，也不需要额外的类似梯度裁剪的稳定技术 ；相比监督训练，从头开始训练具有1.4指标提升(ViT-L)。也即是说：监督预训练并不一定比随机初始化更强；MoCoV3具有与监督预训练相当的性能；对于ViT-B，BEiT与MAE均优于随机初始化与监督预训练；对于ViT-L，BEiT与MAE带来的性能提升进一步扩大，比监督预训练高达4.0.上图给出了预训练是如何影响微调收敛的，可以看到：相比随机初始化，预训练初始化可以显著加速收敛过程，大约加速4倍 。Discussion对于迁移学习来说，COCO数据集极具挑战性。由于较大的训练集(约118K+0.9M标准目标)，当随机初始化训练时可以取得非常好的结果。我们发现：现有的方法(如监督预训练、MoCoV3无监督预训练)的性能反而会弱于随机初始化基线方案 。已有的无监督迁移学习改进对比的均为监督预训练，并不包含随机初始化方案；此外，他们采用了较弱的模型，具有更低的结果(约40)，这就导致：不确定如何将已有方法迁移到SOTA模型中。我们发现：MAE与BEiT提供了首个令人信服的COCO数据集上的指标提升 。更重要的是：这些masking方案具有随模型大小提升进一步改善检测迁移学习能力的潜力 ，而监督预训练与MoCoV3等初始化方式并无该能力。Ablations and Analysis上表对比了单尺度与多尺度版本Mask R-CNN的性能，从中可以看到：多尺度FPN设计可以带来1.3-1.7指标提升 ，而耗时仅提升5-10%，多尺度内存占用提升小于1%。上表对比了降低显存与时间复杂度的不同策略，可以看到：局部+全局的组合方式(即第二种)具有最佳的内存占用与耗时均衡；比纯局部自注意力方式，全局自注意力可以带来2.6指标提升。上表比较了不同位置信息的性能对比，从中可以看到：对于仅使用绝对位置嵌入的预训练模型，在微调阶段引入相对位置偏置可以带来0.2-0.3指标提升；预训练相对位置偏置可以带来0.1-0.3指标增益；相对位置偏置会引入额外的负载：训练与推理耗时分别增加25%和15%，内存占用提升15%。上图对比了预训练周期对于性能的影响，可以看到：在100-800epoch预训练周期下，越多的预训练周期带来越高的迁移学习性能；在800-1600epoch下，仍可带来0.2指标的性能增益。上图给出了TIDE工具生成的误差分析，可以看到：对于正确定位的目标，所有的初始化可以得到相似的分类性能；相比其他初始化，MAE与BEiT可以改善定位性能。上表给出了不同骨干的复杂度对比(ViT-B与ResNet-101具有相同的性能：48.9)，可以看到：在推理耗时方面，ResNet-101骨干更快；在训练方面，ViT-B仅需200epoch即可达到峰值性能，而ResNet-101需要400epoch。

目标网络结构上，作者依次尝试了 ViT-S/16, ViT-B/16, ViT-L/16, 和 Swin-T/{7,14}，7和14代表 window size。优化器使用 AdamW，batch size=1024。在 ImageNet-1k 上预训练 ViT-S/16，ViT-B/16 和 Swin-T/{7,14} 的 Epoch 数分别是800,400和300。在 ImageNet-22k 上预训练 ViT-B/16，ViT-L/16 的 Epoch 数分别是80和50。学习率 Linear warmup 10个 epochs 到  。weight decay 从0.04余弦退火到0.4。Student temperature=0.1，Teacher temperature=0.04到0.07。1.7 ImageNet-1k 实验结果：1 kNN： 把目标网络 Backbone 部分的权重冻结，在模型最后使用 k-nearest 完成分类。2 Linear Probing： 把目标网络 Backbone 部分的权重冻结，在模型最后添加一层线性分类器 Linear Classifier (它其实就是一个 FC 层) 完成分类，只训练 Linear Classifier 的参数。以上结果如下图8所示，只使用 ImageNet-1k 数据集时，使用 ViT-S/16 模型得到的 kNN 和 Linear Probing 的 Accuracy 分别是：75.2%和77.9%。使用 ViT-B/16 模型得到的 kNN 和 Linear Probing 的 Accuracy 分别是：77.1%和79.5%。使用 Swin-T/{7,14} 模型得到的 Linear Probing 的 Accuracy 分别是：78.6%和79.3%，超过了之前 EsViT 的78.1%和78.7%。借助 ImageNet-22k 数据集，使用 ViT-L/16 模型得到的 Linear Probing 的 Accuracy 是：81.6%，使用 ViT-B/16 模型得到的 Linear Probing 的 Accuracy 是：79.5%。3 Fine-tuning： 在模型最后添加一层线性分类器 Linear Classifier (它其实就是一个 FC 层) 完成分类，同时使用全部 label 训练目标网络 Backbone 部分的权重和分类器的权重。结果如下图9所示：只使用 ImageNet-1k 数据集时，使用 ViT-S/16 模型得到的 Fine-tuning 的 Accuracy 是：82.3%，使用 ViT-B/16 模型得到的 Fine-tuning 的 Accuracy 是：83.8%。借助 ImageNet-22k 数据集，使用 ViT-S/16 模型得到的 Fine-tuning 的 Accuracy 是：84.4%，使用 ViT-B/16 模型得到的 Fine-tuning 的 Accuracy 是：86.3%。注意 MAE 使用 ViT-B/16 达到 83.6% 线性分类准确度 (fine-tuning) ，没超越 iBOT 的 83.8%。MAE 使用 ViT-B/16 达到 68% 线性分类准确度 (Linear Probing) ，也没超越 iBOT 的 79.5% 。4 Semi-supervised Learning： 在模型最后添加一层线性分类器 Linear Classifier 完成分类，同时只使用1% 或10%的 label 训练目标网络 Backbone 部分的权重和分类器的权重。结果如下图10所示：只使用1% 或10%的 label 做 Fine-tuning 以后，可以分别达到61.9% 和 75.1% 的 Top-1 Accuracy。

在 NLP 的大规模模型训练中，MLM (Masked Language Modeling）是非常核心的训练目标，其思想是遮住文本的一部分并通过模型去预测这些遮住部分的语义信息，通过这一过程可以使模型学到泛化的特征。NLP 中的经典方法 BERT 就是采用了 MLM 的预训练范式，通过 MLM 训练的模型已经被证明在大模型和大数据上具备极好的泛化能力，成为 NLP 任务的标配。但是在大多数 CV 中的自监督学习任务里面，关注的往往是图片的 global view，比如 MoCo v3。而没有认真研究 image 的内部结构，也就不算是真正的 MIM (Masked Image Modeling)。对于 NLP 任务的 MLM 中，lingual tokenizer 非常重要。它的任务是把 language 变成富含文本语义的 tokens。与此相似，对于 CV 任务的 MIM 中，visual tokenizer 非常重要。它的任务是把 image 变成富含图像语义的 tokens。但是，图片不像是文本，文本中自然蕴含有语言的语义信息，NLP 中 tokenization 通过离线的词频分析即可将语料编码为含高语义的分词。但是图片不一样，图片的信息比较连续，图像 patch 是连续分布的且存在大量冗余的底层细节信息，而图像 patch token 的语义信息丰富。所以图像 patch 的 visual semantic 信息不那么容易被提取。这个属性直观地带来了一个多阶段的训练策略，即：在训练目标模型之前，我们需要首先训练一个 off-the-shelf 的 tokenizer，它能够把 image 转换成语义丰富的 tokens。BEiT 中使用的是一个 Pre-trained discrete VAE 作为 tokenizer。虽然提供了一定程度的抽象，但discrete VAE 仍然只能在局部细节中捕获低级语义。

 iBOT论文名称：iBOT:Image BERT Pre-training with Online Tokenizer论文地址：https://arxiv.org/abs/2111.07832前段时间，何恺明等人的一篇论文成为了计算机视觉圈的焦点。这篇论文仅用简单的 idea（即掩蔽自编码器，MAE）就达到了非常理想的性能，让人们看到了 Transformer 扩展到 CV 大模型的光明前景，给该领域的研究者带来了很大的鼓舞：深度了解自监督学习，就看这篇解读 ！何恺明新作MAE：通向CV大模型在字节提出的一篇最新的论文 iBOT 中，他们提出了适用于视觉任务的大规模预训练方法，通过对图像使用在线 tokenizer 进行 BERT 式预训练让 CV 模型获得通用广泛的特征表达能力。该方法在十几类任务和数据集上刷新了 SOTA 结果，在一些指标上甚至超过了 MAE。1.1 Self-supervised Learning在预训练阶段我们使用无标签的数据集 (unlabeled data)，因为有标签的数据集很贵，打标签得要多少人工劳力去标注，那成本是相当高的，太贵。相反，无标签的数据集网上随便到处爬，它便宜。在训练模型参数的时候，我们不追求把这个参数用带标签数据从初始化的一张白纸给一步训练到位，原因就是数据集太贵。于是 Self-Supervised Learning 就想先把参数从一张白纸训练到初步成型，再从初步成型训练到完全成型。注意这是2个阶段。这个训练到初步成型的东西，我们把它叫做 Visual Representation。预训练模型的时候，就是模型参数从一张白纸到初步成型的这个过程，还是用无标签数据集。等我把模型参数训练个八九不离十，这时候再根据你下游任务 (Downstream Tasks) 的不同去用带标签的数据集把参数训练到完全成型，那这时用的数据集量就不用太多了，因为参数经过了第1阶段就已经训练得差不多了。第一个阶段不涉及任何下游任务，就是拿着一堆无标签的数据去预训练，没有特定的任务，这个话用官方语言表达叫做：in a task-agnostic way。第二个阶段涉及下游任务，就是拿着一堆带标签的数据去在下游任务上 Fine-tune，这个话用官方语言表达叫做：in a task-specific way。以上这些话就是 Self-Supervised Learning 的核心思想，如下图1所示，后面还会再次提到它。图1：Self-Supervised Learning 的核心思想Self-Supervised Learning 不仅是在NLP领域，在CV, 语音领域也有很多经典的工作，如下图2所示。它可以分成3类：Data Centric, Prediction (也叫 Generative) 和 Contrastive。图2：各个领域的 Self-Supervised Learning其中的主流就是基于 Generative 的方法和基于 Contrative 的方法。如下图 3 所示这里简单介绍下。基于 Generative 的方法主要关注的重建误差，比如对于 NLP 任务而言，一个句子中间盖住一个 token，让模型去预测，令得到的预测结果与真实的 token 之间的误差作为损失。基于 Contrastive 的方法不要求模型能够重建原始输入，而是希望模型能够在特征空间上对不同的输入进行分辨。图3：基于 generative 的方法和基于 contrastive 的方法的总结图片

谭婧等的方法总体上来说是一种监督型的训练方法，因此需要一个带有Ground Truth信息的数据集。然而以前从来没有广角畸变校正的标准数据集，因此作者用5个超广角的拍照手机，在各种场景下进行采集，制作了一个超过5000张图像的数据集，每张图像的人像分布在1到6人之间。由于有这几个相机的畸变参数，因此可以很容易的获得镜头畸变校正的map，作为LineNet训练时的Ground Truth。接下来，为了获得每张图像对应的透视畸变校正后的图像，作者们基于施易昌等的方法开发了一个自动化的校正工具，其中刻意在原方法的目标函数的基础上添加了一个人脸附近的直线约束，使得能够更好的保持人脸附近的直线。作者们还开发了一个微调工具，可以基于Mesh来对图像的局部进行微调。通过联合使用校正工具+微调工具，她们得到了一个效果很好的数据集，下图d是最终手动优化后的效果，可以看到它确实比施易昌等的方法结果好(图b)，例如这里人脸附近的大楼阳台保持了直线。下面展示了数据集中需要包括的内容输入的图像(完全未经畸变校正)经过镜头畸变校正后的图像(此时直线被校直)经过透视畸变校正后的图像(此时背景直线校直，且人脸畸变被消除)人脸Mask直线标注信息镜头畸变校正Map透视畸变校正Map

       首先作为一名在校大学生，我在此非常感谢华为云能够提供本次免费的HCIA-Cloud Service职业认证集训营。使用华为云DevCloud实现20分钟一行代码上云和基于DevCloud进行黑白棋实时对战游戏开发都是开发方向的，对于我一直偏向运维方向的云计算来说有一点挑战性，但总体来说还是非常简单明确的，完成两个任务体验上云的易用性和便捷性。课程内容也是比较基础，理论部分通俗易懂，基本触及我所学知识面。综上所述，这次训练营非常好的展现了华为云的培训方面的优势和能力，当然我也是冲着奖品来学习的，所以学习的动力很强。同时非常感谢学习群内的助理和同学耐心解答我的疑问。通过本次学习，我学会了云服务器ECS和VPC里面的内在逻辑关系，以及基础的开发流程，Devops ,  devcloud，以及云计算服务，弹性云服务等。学习这些知识后也弥补了我在开发中知识面的空缺，相信下次的职业认证集训营我一定会再次参加！

HCIA-Cloud Service V3.0职业认证训练营是一个非常棒的活动，非常感谢华为云提供的这次学习体验机会！偶然的机会看到了这个活动，抱着近距离体验云计算服务的想法，于是报名，入群，学习，打卡，实验，考试，积极参与了进来，整体感觉很不错，活动目标明确，内容充实且有趣味，课程讲解清晰并细致，实验设计精心且步骤详细。HCIA-Cloud Service认证定位于培养与认证掌握公有云最前沿知识技能，能够熟练使用华为云服务产品的工程师。面向有认证需求的在校大学生、云计算初学者、开发者、云服务工程师等人员群体及相关华为云伙伴；通过HCIA-Cloud Service认证，将证明您掌握云服务概念和价值，华为云服务架构和生态，华为云计算服务、存储服务、网络服务、安全服务、管理与监控、关系型数据库、CDN&云视频服务和创新应用服务的管理和应用，具备使用各类云服务产品进行应用部署和维护的能力，可以助力企业实现ICT环境的云转型。学习体验之后，对云计算云服务有了进一步的认识，希望有时间能多参与类似活动。再次感谢华为云！