diff --git a/best_practices/contrib/ganomaly/README.md b/best_practices/contrib/ganomaly/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bdf0c8c5937d221e3f5df4e6f22b27685914f641 --- /dev/null +++ b/best_practices/contrib/ganomaly/README.md @@ -0,0 +1,268 @@ +- [基本信息.md](#基本信息md) + - [简述](#简述) + - [支持特性](#支持特性) +- [准备训练环境](#准备训练环境) + - [准备环境](#准备环境) + - [准备数据集](#准备数据集) +- [开始训练](#开始训练) + - [训练模型](#训练模型) +- [性能结果展示](#性能结果展示) +- [版本说明](#版本说明) + - [变更](#变更) + - [已知问题](#已知问题) + +# 基本信息.md + +**发布者（Publisher）：Huawei** + +**应用领域（Application Domain）：Classification** + +**版本（Version）：1.0** + +**修改时间（Modified） ：2022.12.01** + +**大小（Size）：** + +**框架（Framework）：PyTorch 1.8.1** + +**模型格式（Model Format）：pth** + +**处理器（Processor）：昇腾 310** + +**应用级别（Categories）：Official** + +**描述（Description）：基于人工智能的零件表面质量检测算法** + +## 简述 + +用于检测工业零件表面缺陷的无监督质量检测代码—PyTorch 实现 + +- 参考模型： + Baseline 模型 + + ``` + url=https://github.com/samet-akcay/ganomaly + ``` + +- 适配昇腾 AI 处理器的实现： + + ``` + url= + ``` + +- 通过 Git 获取代码方法如下： + + ``` + git clone {url} # 克隆仓库的代码 + cd {code_path} # 切换到模型代码所在路径，若仓库下只有该模型，则无需切换 + ``` + +## 支持特性 + +| 特性列表 | 是否支持 | +| ---------- | -------- | +| 分布式训练 | 否 | +| 混合精度 | 是 | + +# 准备训练环境 + +## 准备环境 + +- 当前模型支持的固件与驱动、 CANN 以及 PyTorch 如下表所示。 + + **表 1** 版本配套表 + + | 配套 | 版本 | + | ---------- | -------------------------------------------------------------------------------------------------------------- | + | 固件与驱动 | [1.0.15](https://www.hiascend.com/hardware/firmware-drivers?tag=commercial) | + | CANN | [5.1.RC1](https://www.hiascend.com/software/cann/commercial?version=5.1.RC1) | + | PyTorch | [1.8.1](https://gitee.com/ascend/pytorch/tree/master/)或[1.5.0](https://gitee.com/ascend/pytorch/tree/v1.5.0/) | + +- 环境准备指导。 + + 请参考《[Pytorch 框架训练环境准备](https://www.hiascend.com/document/detail/zh/ModelZoo/pytorchframework/ptes)》。 + +- 安装依赖（根据模型需求，按需添加所需依赖）。 + + ``` + pip install -r requirements.txt + ``` + +## 准备数据集 + +1. 获取数据集。 + + - 用户自行获取原始数据集，可选用的开源数据集包括 CIFAR-10 ，将数据集上传到服务器任意路径下，解压到`./data`文件夹下。 + - 我们的零件表面质量存放在`./data/MainBoard`文件夹下。 + + 数据集内结构如下所示。 + + ``` + Custom Dataset + ├── test + │   ├── 0.normal + │ │   └── 正常类图片_0.png + │ │   └── 正常类图片_1.png + │ │   ... + │ │   └── 正常类图片_n.png + │   ├── 1.abnormal + │ │   └── 异常类图片_0.png + │ │   └── 异常类图片_1.png + │ │   ... + │ │   └── 异常类图片_m.png + ├── train + │ ├── 0.normal + │ │   └── 正常类图片_0.png + │ │   └── 正常类图片_1.png + │ │   ... + │ │   └── 正常类图片_k.png + + ``` + + > **说明：** + > 该数据集的训练过程脚本只作为一种参考示例。 + +2. 数据预处理 。 + 可自行添加数据翻转、裁剪等数据增强技术 + +## 获取源码包 + + 可以使用以下两种方式下载，请选择其中一种进行源码准备。 + - 命令行方式下载。 + ``` + # 开发环境，非root用户命令行中执行以下命令下载源码仓。 + git clone https://gitee.com/ascend/samples.git + + # 切换到模型代码所在路径 + cd best_practices/contrib/ganomaly + ``` + + - 压缩包方式下载（下载时间较短，但步骤稍微复杂）。 + **注：如果需要下载其它版本代码，请先请根据前置条件说明进行samples仓分支切换。** + ``` + # 1. samples仓右上角选择 【克隆/下载】 下拉框并选择 【下载ZIP】。 + # 2. 将ZIP包上传到开发环境中的普通用户家目录中，【例如：${HOME}/ascend-samples-master.zip】。 + # 3. 开发环境中，执行以下命令，解压zip包。 + cd ${HOME} + unzip ascend-samples-master.zip + # 4. 切换到模型代码所在路径 + cd $HOME/samples/best_practices/contrib/ganomaly + ``` + + + +# 开始训练 + +## 训练模型 + +1. 进入解压后的源码包根目录。 + + ``` + cd /${模型文件夹名称} + ``` + +2. 运行训练脚本。 + + 该模型支持单机单卡训练 + + - 单机单卡 NPU 训练 + + ``` + # 训练Mainboard数据集： + python3 train_npu_1p.py + ``` + + - 单机单卡 GPU 训练 + + ``` + # 训练cifar10数据集： + sh test/run_cifar.sh + ``` + + ``` + # 训练自制数据集: + python3 train.py + --model + --datase + --isize + --niter + --batchsize + --w_con 50 --save_test_images + ``` + + 模型训练脚本参数说明如下。 + + ``` + 公共参数： + --dataset //数据集路径 + --model //使用模型， + --workers //加载数据进程数 + --niter //重复训练次数 + --batchsize //训练批次大小 + --lr //初始学习率 + --momentum //动量 + --weight_decay //权重衰减 + --abnormal_class //异常类别 + --isize //输入图像大小 + --amp //是否使用混合精度，默认使用 + --loss-scale //混合精度lossscale大小 + --opt-level //混合精度类型，默认O2 + ``` + + > **说明：** + > 更多参数信息： `run python train.py -h`. + > 训练完成后，权重文件保存在`./output/skipganomaly/{dataset_name}/train/weight/` + +3. 模型转换。 原始模型转换为适配昇腾910处理器的离线模型（*.om文件） + + ``` + python convertOnnx.py + atc --model=netd_npu.onnx --output=/home/test_user01/wbytest/Skip-Attention-GAN/netD --soc_version=Ascend310 --framework=5 + atc --model=netg_npu.onnx --output=/home/test_user01/wbytest/Skip-Attention-GAN/netG --soc_version=Ascend310 --framework=5 + ``` + + +# 样例运行 +### 部署环境 + +**注：开发环境与运行环境合一部署，请跳过部署环境，直接执行[训练与测试文件](#step_2)即可。** + +执行以下命令,将开发环境的 **ganomaly** 目录上传到运行环境中，例如 **/home/HwHiAiUser**，并以HwHiAiUser（运行用户）登录运行环境（Host）。 + + + # 【xxx.xxx.xxx.xxx】为运行环境ip，200DK在USB连接时一般为192.168.1.2，300（ai1s）为对应的公网ip。 + scp -r $HOME/samples/best_practices/contrib/ganomaly HwHiAiUser@xxx.xxx.xxx.xxx:/home/HwHiAiUser + ssh HwHiAiUser@xxx.xxx.xxx.xxx + cd $HOME/samples/best_practices/contrib/ganomaly +### 放入测试文件 + # 执行以下命令，将测试图片存入test目录下 + mv test.jpg ./data + +### 运行测试文件 + + python3 ganomalyTest.py + + +# 性能结果展示 + +此处展示在相同的参数设置下，不同模型在但 NPU 下的 AUC 值。 + +| 模型 | AUC | Epochs | Batchsize | AMP_Type | ms/batch | +|:-------------:|:----:| :----: | :-------: | :------: | :------: | +| skip-ganomaly | 0.69 | 15 | 128 | - | 4.74 | +| - | 0.69 | 15 | 128 | O2 | 4.49 | +| 1P-NPU | 0.98 | 15 | 128 | - | 12.52 | +| - | 0.98 | 15 | 128 | O2 | 11.12 | +| 推理OM模型 | 0.55 | - | 1 | - | 0.1 | + +# 版本说明 + +## 变更 + +2022.12.01：首次发布。 + +## 已知问题 + +**_当前发行版本中存在的问题描述。_** + +无。 diff --git a/best_practices/contrib/ganomaly/acl.json b/best_practices/contrib/ganomaly/acl.json new file mode 100644 index 0000000000000000000000000000000000000000..56a513446e0baaf44d0cdeb3027e763f679a1046 --- /dev/null +++ b/best_practices/contrib/ganomaly/acl.json @@ -0,0 +1,7 @@ +{ +"profiler": { + "switch": "on", + "output": "output", + "aicpu": "on" + } +} \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/acllite/README.md b/best_practices/contrib/ganomaly/acllite/README.md new file mode 100644 index 0000000000000000000000000000000000000000..984c340b34a7875eb4a03bf7619b6a189c150e00 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/README.md @@ -0,0 +1,339 @@ +English|[中文](README_CN.md) + +# Python_acllite Usage Description + +## Usage + +1. This library is used only for open source samples in the current community. It does not cover all application development scenarios of the Ascend platform and cannot be used as a standard library for user application development. + +2. This library is verified only on the Atlas 200 DK and Atlas 300 (x86) servers. + +## Constraints + +| Adaptation Item | Adaptation Condition | Remarks | +| ---------- | ------------------------------------------------------------ | ------------------------------------------------------------ | +| Applicable version | ≥ 5.0.4 | The version has been installed. For details about the version information, see [Version Number Change Notice](https://www.hiascend.com/en/software/cann/notice).| +| Applicable hardware | Atlas 200 DK/Atlas 300 ([AI1s](https://support.huaweicloud.com/productdesc-ecs/ecs_01_0047.html#ecs_01_0047__section78423209366))| The library has passed the tests on Atlas 200 DK and Atlas 300. For details about the product description, see [Hardware](https://www.hiascend.com/en/hardware/product).| +| Third-party dependency| pyav, NumPy, and Pillow | Install the dependencies by referring to [Third-Party Dependency Installation Guide (Python Sample)](../../environment).| + + +## Procedure + +#### Public Library Deployment + +Before running the application, deploy the public library to the operating environment. For details, see [Third-Party Dependency Installation Guide (Python Sample)](../../environment). +Then, add the path to the PYTHONPATH environment variable. For example, in the preceding document, the public library is copied to `$THIRDPART_PATH`. Add the following information to the **~/.bashrc** file: + +``` +export PYTHONPATH=$THIRDPART_PATH/acllite:$PYTHONPATH +``` + +Save the configured environment variable and run the following command to make the environment variable take effect: + +``` +source ~/.bashrc +``` + +After the preceding steps are complete, call the acllite library interfaces in the application code. For example: + +``` +import presenteragent.presenter_channel as presenter_channel + +chan = presenter_channel.open_channel(config_file) +``` + +## Interface Description + +### AclLiteImage Class + +Provided in the python-acllite public library, the AclLiteImage class provides a unified data encapsulation structure for the Atlas 200 DK camera, JPG images, and input image data to facilitate subsequent processing by the public library interfaces. + +#### \_\_init\_\_ + +Method: \_\_init\_\_ (image, width=0, height=0, size=0, memory_type=const.MEMORY_NORMAL): + +Note: + +Generates data of the AclLiteImage structure based on the initialization parameter list. + +Input parameter: + +**image**: image data. It can be NumPy arrays, JPEG/PNG image paths, and memory data. If this parameter is left blank or set to an unsupported type, an error is reported. + +**width**: image width. If the image is a JPEG or PNG image, this parameter can be left empty. In this case, the default value **0** is used. + +**height**: image height. If the image is a JPEG or PNG image, this parameter can be left empty. In this case, the default value **0** is used. + +**size**: image data size. If the image is a JPEG or PNG image, this parameter can be left empty. In this case, the default value **0** is used. + +**memory_type**: image data storage type, that is, whether the image data is stored in the normal memory, device memory, host memory, or DVPP memory. If the image is a JPEG or PNG image, this parameter can be left empty. In this case, the default value **MEMORY_NORMAL** is used. + +Return value: + +Data of the AclLiteImage structure + +Constraints: + +None + +#### save + +Method: save(filename): + +Note: + +Converts the AclLiteImage data into the NumPy array and saves it as a binary file. + +Input parameter: + +**filename**: name of the saved file. + +Return value: + +None + +Constraints: + +None + +### Camera Class + +The Camera class provides Python interfaces for Atlas 200 DK onboard camera decoding. + +#### is_opened + +Method: is_opened() + +Note: + +Checks whether the onboard camera of the Atlas 200 DK is opened based on the camera ID of the initialized cameracapture class object. + +Input parameter: + +None + +Return value: + +**TRUE**: The camera is turned on. + +**FALSE**: The camera is not turned on. + +Constraints: + +None + +#### read + +Method: read() + +Note: + +Reads images from the camera specified by the ID during initialization of the cameracapture class object and saves the images as data in the AclLiteImage structure. + +Input parameter: + +None + +Return value: + +Image data of the AclLiteImage type + +Constraints: + +None + +#### close + +Method: close() + +Note: + +Close the camera. + +Input parameter: + +None + +Return value: + +None. If the command is executed properly, the **Close camera** field is displayed. + +Constraints: + +None + +### AclLiteModel Class + +Provided in the python-acllite library, the AclLiteModel class encapsulates APIs related to ACL model inference, including but not limited to model loading and initialization, creation of model input and output datasets, model inference execution, and resource release. + +#### execute + +Method: execute(input_list) + +Note: + +Model inference API, which converts the input data into ACL dataset data and sends the data to the model for inference. The inference result is represented in NumPy array. + +Input parameter: + +**input_list**: model input data, which can be AclLiteImage, NumPy array, or {'data': ,'size':} dict structure data. + +Return value: + +**NumPy array**, which is used to represent the model inference result. + +Constraints: + +None + + +### AclLiteImageProc Class + +Provided in the python-acllite library, the AclLiteImageProc class encapsulates CANN media data processing APIs, including but not limited to image decoding and encoding, video decoding and encoding, and image cropping and resizing. + +#### jpegd + +Method: jpegd(image): + +Note: + +Image decoding API, which is used to convert JPEG images into YUV images. + +Input parameter: + +**image**: original JPEG image data, which is stored in the AclLiteImage structure. + +Return value: + +**AclLiteImage**: stores YUV image data. + +Constraints: + +None + +#### jpege + +Method: jpege(image): + +Note: + +Image decoding API, which is used to convert YUV images into JPEG images. + +Input parameter: + +**image**: original YUV image data, which is stored in the AclLiteImage structure. + +Return value: + +**AclLiteImage**: stores JPEG image data. + +Constraints: + +None + +#### crop_and_paste + +Method: crop_and_paste(image, width, height, crop_and_paste_width, crop_and_paste_height) + +Note: + +Image vision preprocessing core (VPC) API, which is used to crop the original image and paste it to the target size. + +Input parameter: + +**image**: original image data, which is stored in the AclLiteImage structure. + +**width**: width of the original image. + +**height**: height of the original image. + +**crop_and_paste_width**: width of the target image after the VPC. + +**crop_and_paste_height**: height of the target image after the VPC. + +Return value: + +**AclLiteImage**: stores the image data after the VPC. + +Constraints: + +None + +#### resize + +Method: resize(image, resize_width, resize_height) + +Note: + +Resizes the input image to the specified size. + +Input parameter: + +**image**: original image data, which is stored in the AclLiteImage structure. + +**resize_width**: destination image width. + +**resize_height**: destination image height. + +Return value: + +**AclLiteImage**: stores the image data after resizing. + +Constraints: + +None + +### Dvpp_Vdec Class + +Provided in the python-acllite library, the Dvpp_Vdec class encapsulates video stream decoding interfaces, including video stream frame cut. + +#### read + +Method: read(no_wait): + +Note: + +Video frame read interface (asynchronous), which reads data from the queue and sends the data to the decoder. + +Input parameter: + +**no_wait**: Boolean variable. If the value is **true**, data is continuously read from the queue. The **is_finished ()** interface is used to check whether the frame data is decoded completely. If the value is **false**, data is read from the queue at the interval specified by **READ_TIMEOUT**. If the value is empty, an error is reported. The default value is **false**. + +Return value: + +**ret**: interface execution result. **SUCCESS** indicates that the execution is successfully completed. **FAILED** indicates that the interface fails to read data from the queue because some data is not decoded. + +**image**: video frame that is read. + +Constraints: + +The video stream must be in one of the following formats: + +H.264: main, baseline, or high level, and in the annex-b format + +H.265: main level + +#### process + +Method: process(input_data, input_size, user_data) + +Note: + +Video decoding interface. It transmits the video frame data to be decoded to the decoder. + +Input parameter: + +**input_data**: input data. + +**input_size**: size of the input data. + +**user_data**: Python object (user-defined). If you want to obtain the sequence number of the decoded frame, define the **user_data** parameter. Then, the sequence number can be passed to the VDEC callback function to determine the frame to be processed. + +Return value: + +**ret**: interface execution result. The value can be **SUCCESS** or **FAILED**. + + +Constraints: + +None diff --git a/best_practices/contrib/ganomaly/acllite/README_CN.md b/best_practices/contrib/ganomaly/acllite/README_CN.md new file mode 100644 index 0000000000000000000000000000000000000000..efb2b6a13ee380ef8226f832f8a657b4374e2d79 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/README_CN.md @@ -0,0 +1,361 @@ +中文|[English](README.md) +# python acllite使用说明 + +## 使用说明 + +1.本库仅供当前社区开源样例使用，不覆盖ascend平台应用开发的所有场景，不作为用户应用开发的标准库； + +2.本库仅在Atlas200DK和Atlas300（x86）服务器上做了验证。 + +## 使用约束 + +| 适配项 | 适配条件 | 备注 | +|---|---|---| +| 适配版本 | >=5.0.4 | 已完成版本安装，版本信息请参考[版本说明](https://ascend.huawei.com/zh/#/software/cann/notice) | +| 适配硬件 | Atlas200DK/Atlas300([ai1s](https://support.huaweicloud.com/productdesc-ecs/ecs_01_0047.html#ecs_01_0047__section78423209366)) | 当前已在Atlas200DK和Atlas300测试通过，产品说明请参考[硬件平台](https://ascend.huawei.com/zh/#/hardware/product) | +| 第三方依赖 | pyav、numpy、Pillow等| 请参考[第三方依赖安装指导（python样例）](../../environment)完成对应依赖安装 | + + +## 使用步骤 + +#### 2.公共库部署 + +运行应用前需要先将公共库部署到运行环境，具体安装步骤参考[第三方依赖安装指导（python样例）](../../environment)。 +完成后，将该目录路径加入PYTHONPATH环境变量即可。例如在以上文档中，公共库被拷贝到```$THIRDPART_PATH```，在~/.bashrc文件中添加： + +``` +export PYTHONPATH=$THIRDPART_PATH/acllite:$PYTHONPATH +``` + +保存配置好的环境变量，执行以下命令使环境变量生效 + +``` +source ~/.bashrc +``` + +完成以上步骤后，即可在应用的代码中调用acllite库的接口，例如： + +``` +import presenteragent.presenter_channel as presenter_channel + +chan = presenter_channel.open_channel(config_file) +``` + +## 接口说明 + +### AclLiteImage类 + +AclLiteImage类为python-acllite公共库，针对atlas200dk摄像头、jpg图片、输入的图片数据，所提供的一套统一的数据封装结构，便于后续公共库接口对其进行处理。 + +#### \_\_init\_\_ + +方法：\_\_init\_\_ (image, width=0, height=0, size=0, memory_type=const.MEMORY_NORMAL): + +说明： + +根据初始化参数列表，生成对应的AclLiteImage结构的数据。 + +输入参数： + +image ：图片数据，支持numpy array、jpeg/png图片路径、内存数据作为参数输入；不填/填写不支持类型输入会报错。 + +width ：图片宽；如果image为jpeg/png图片，该参数可不填；不填则填入默认参数0。 + +height ：图片高；如果image为jpeg/png图片，该参数可不填；不填则填入默认参数0。 + +size ：图片数据大小，如果image为jpeg/png图片，该参数可不填；不填则填入默认参数0。 + +memory_type ：图片数据存储类型，即该图片数据是存储在一般内存、device、host或是dvpp内存；如果image为jpeg/png图片，该参数可不填；不填则填入默认参数 MEMORY_NORMAL。 + +返回值： + +AclLiteImage结构的数据 + +约束： + +无 + +#### save + +方法：save(filename): + +说明： + +将AclLiteImage数据转换为np array后。保存为二进制文件。 + +输入参数： + +filename ： 保存后的文件名 + +返回值： + +无 + +约束： + +无 + +### Camera类 + +Camera类为Atlas200DK板载摄像头解码提供python接口。 + +#### is_opened + +方法：is_opened（） + +说明： + +根据初始化的cameracapture类对象的摄像头id，判断Atlas200DK板载摄像头是否已打开。 + +输入参数： + +无 + +返回值： + +1.TRUE，摄像头已打开 + +2.FALSE，摄像头未打开 + +约束： + +无 + +#### read + +方法：read（） + +说明： + +根据cameracapture类对象初始化时的id，从该id表示的摄像头读取图片，并将图片保存为AclLiteImage结构的数据。 + +输入参数： + +无 + +返回值： + +AclLiteImage类型的图片数据 + +约束： + +无 + +#### close + +方法：close（） + +说明： + +关闭打开的摄像头 + +输入参数： + +无 + +返回值： + +无，正常执行会打印 "Close camera" 字段。 + +约束： + +无 + +### AclLiteModel类 + +AclLiteModel类为python-acllite对acl模型推理相关接口的封装，包括但不限于模型加载与初始化，模型输入输出dataset的创建，模型推理执行及资源释放等功能。 + +#### __init__ + +方法：AclLiteModel(model_path, load_type) + +说明： + +模型推理类初始化 + +输入数据： + +model_path：模型的路径。 + +load_type：加载模型的方式，可选0和1，默认值为0。（0：从文件加载离线模型数据；1：从内存加载离线模型数据） + +返回值： + +无 + +约束： + +无 + +#### execute + +方法：execute (input_list): + +说明： + +模型推理接口，将输入数据转变为acl dataset类型数据后送给模型做推理，推理结果以numpy array表示 + +输入参数： + +input_list：模型输入数据，支持AclLiteImage、numpy array 和{'data': ,'size':} dict 结构数据。 + +返回值： + +numpy array，用来表示模型推理结果。 + +约束： + +无 + + +### AclLiteImageProc类 + +AclLiteImageProc类为python-acllite对CANN媒体数据处理相关接口的封装，包括但不限于图片解码编码，视频解码编码，抠图缩放等功能。 + +#### jpegd + +方法：jpegd(image): + +说明： + +图片解码接口，将jpeg格式图片转换为yuv格式 + +输入参数： + +image：原始jpeg图片数据，以AclLiteImage结构存储的数据。 + +返回值： + +AclLiteImage，用来存放yuv图片数据。 + +约束： + +无 + +#### jpege + +方法：jpege(image): + +说明： + +图片解码接口，将yuv格式图片转换为jpeg格式 + +输入参数： + +image：原始yuv图片数据，以AclLiteImage结构存储的数据。 + +返回值： + +AclLiteImage，用来存放jpeg图片数据。 + +约束： + +无 + +#### crop_and_paste + +方法：crop_and_paste(image, width, height, crop_and_paste_width, crop_and_paste_height) + +说明： + +图片VPC（vision preprocessing core）功能相接口，将原始图片扣出再贴到目标大小 + +输入参数： + +image：原始图片数据，以AclLiteImage结构存储的数据。 + +width：原始图片宽。 + +height：原始图片高。 + +crop_and_paste_width：VPC后目标图片的宽 + +crop_and_paste_height：VPC后目标图片的高 + +返回值： + +AclLiteImage，用来存放vpc后的图片数据。 + +约束： + +无 + +#### resize + +方法：resize(image, resize_width, resize_height) + +说明： + +将输入图片resize到指定大小。 + +输入参数： + +image：原始图片数据，以AclLiteImage结构存储的数据。 + +resize_width：缩放后图片的宽。 + +resize_height：缩放后图片的高。 + +返回值： + +AclLiteImage，用来存放resize后的图片数据。 + +约束： + +无 + +### Dvpp_Vdec类 + +Dvpp_Vdec类为python-acllite对视频流的解码相关接口的封装。包括了对视频流的切帧等。 + +#### read + +方法：read (no_wait): + +说明： + +视频帧读接口，异步接口，负责从队列中读取数据并送去解码。 + +输入参数： + +no_wait：布尔变量，为真则不断从队列中读取数据，需要使用is_finished（）接口来判断该帧数据是否解码完毕；为否则会按照READ_TIMEOUT设置的时间间隔从队列里读取数据，为空则会报错；默认为否。 + +返回值： + +ret ：接口执行结果；SUCCESS为正常；FAILED表示失败，有数据未解码，但是接口未从队列中读取到数据。 + +image ：读到的视频帧 + +约束： + +视频流必须为以下格式之一： + +h264 ：main, baselineor high level，且为 annex-b格式 + +h265 ：main level + +#### process + +方法：process (input_data, input_size, user_data) + +说明： + +视频解码接口，将需要解码的视频帧数据送给解码器做处理。 + +输入参数： + +input_data ：输入数据。 + +input_size ：输入数据大小。 + +user_data ：python对象，用户自定义数据。如果用户需要获取解码的帧序号，则可以在user_data参数处定义，然后解码的帧序号可以通过user_data参数传递给VDEC的回调函数，用于确定回调函数中处理的是第几帧数据。 + +返回值： + +ret ：接口执行结果；SUCCESS为正常；FAILED表示失败 + + +约束： + +无 + diff --git a/best_practices/contrib/ganomaly/acllite/__init__.py b/best_practices/contrib/ganomaly/acllite/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/best_practices/contrib/ganomaly/acllite/acllite_image.py b/best_practices/contrib/ganomaly/acllite/acllite_image.py new file mode 100644 index 0000000000000000000000000000000000000000..a269a4c06d3b8f5f0fd5155d67ef17c02eee6a84 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/acllite_image.py @@ -0,0 +1,220 @@ +import os +import numpy as np +from PIL import Image + +import acl +import acllite_utils as utils +import acllite_logger as acl_log +import constants as const + +class AclLiteImage(object): + """Image data and operation class + Wrap image data and operation method, support jpeg, png, yuv file and + memory data + + Attributes: + _run_mode: device run mode + _data: image binary data or numpy array + _memory_type: the data in which memory, include dvpp, + device and np array + width: image width + height: image height + alignWidth: align image width + alignHeight: align image height + _encode_format: image format + _load_ok: load image success or not + + """ + _run_mode, _ = acl.rt.get_run_mode() + + def __init__(self, image, width=0, height=0, alignWidth=0, alignHeight=0, + size=0, memory_type=const.MEMORY_NORMAL): + """Create AclLiteImage instance + Args: + image: image data, binary, numpy array or file path + width: image width. if image is jpeg or png file, + this arg is not nesscessary + height: image height. if image is jpeg or png file, this arg is + not nesscessary + size: image data size. if image is file path, this arg is not + nesscessary + memory_type: memory type of image data. if image is file path, this + arg is not nesscessary + """ + self._data = None + self._memory_type = memory_type + self.width = 0 + self.height = 0 + self.alignWidth = 0 + self.alignHeight = 0 + self.size = 0 + self._encode_format = const.ENCODE_FORMAT_UNKNOW + self._load_ok = True + + if isinstance(image, str): + self._instance_by_image_file(image, width, height) + elif isinstance(image, int): + self._instance_by_buffer(image, width, height, alignWidth, alignHeight, size) + elif isinstance(image, np.ndarray): + self._instance_by_nparray(image, width, height, alignWidth, alignHeight) + else: + acl_log.log_error("Create instance failed for " + "unknow image data type") + + def _instance_by_image_file(self, image_path, width, height): + # Get image format by filename suffix + self._encode_format = self._get_image_format_by_suffix(image_path) + if self._encode_format == const.ENCODE_FORMAT_UNKNOW: + acl_log.log_error("Load image %s failed" % (image_path)) + self._load_ok = False + return + + # Read image data from file to memory + self._data = np.fromfile(image_path, dtype=np.byte) + self._type = const.IMAGE_DATA_NUMPY + self.size = self._data.itemsize * self._data.size + self._memory_type = const.MEMORY_NORMAL + + # Get image parameters of jpeg or png file by pillow + if ((self._encode_format == const.ENCODE_FORMAT_JPEG) or + (self._encode_format == const.ENCODE_FORMAT_PNG)): + image = Image.open(image_path) + self.width, self.height = image.size + else: + # pillow can not decode yuv, so need input widht and height args + self.width = width + self.height = height + + def _get_image_format_by_suffix(self, filename): + suffix = os.path.splitext(filename)[-1].strip().lower() + if (suffix == ".jpg") or (suffix == ".jpeg"): + image_format = const.ENCODE_FORMAT_JPEG + elif suffix == ".png": + image_format = const.ENCODE_FORMAT_PNG + elif suffix == ".yuv": + image_format = const.ENCODE_FORMAT_YUV420_SP + else: + acl_log.log_error("Unsupport image format: ", suffix) + image_format = const.ENCODE_FORMAT_UNKNOW + + return image_format + + def is_loaded(self): + """Image file load result + When create image instance by file, call this method to check + file load success or not + + Returns: + True: load success + False: load failed + """ + return self._load_ok + + def _instance_by_buffer(self, image_buffer, width, height, alignWidth, alignHeight, size): + self.width = width + self.height = height + self.alignHeight = alignHeight + self.alignWidth = alignWidth + self.size = size + self._data = image_buffer + self._type = const.IMAGE_DATA_BUFFER + + def _instance_by_nparray(self, data, width, height, alignWidth, alignHeight): + self.width = width + self.height = height + self.alignHeight = alignHeight + self.alignWidth = alignWidth + self.size = data.itemsize * data.size + self._data = data + self._type = const.IMAGE_DATA_NUMPY + self._memory_type = const.MEMORY_NORMAL + + def byte_data_to_np_array(self): + """Trans image data to np array""" + if self._type == const.IMAGE_DATA_NUMPY: + return self._data.copy() + + return utils.copy_data_as_numpy(self._data, self.size, + self._memory_type, AclLiteImage._run_mode) + + def data(self): + """Get image binary data""" + if self._type == const.IMAGE_DATA_NUMPY: + if "bytes_to_ptr" in dir(acl.util): + bytes_data=self._data.tobytes() + factor_ptr=acl.util.bytes_to_ptr(bytes_data) + else: + factor_ptr=acl.util.numpy_to_ptr(self._data) + return factor_ptr + else: + return self._data + + def copy_to_dvpp(self): + """Copy image data to dvpp""" + device_ptr = utils.copy_data_to_dvpp(self.data(), self.size, + self._run_mode) + if device_ptr is None: + acl_log.log_error("Copy image to dvpp failed") + return None + return AclLiteImage(device_ptr, self.width, self.height, 0, 0, + self.size, const.MEMORY_DVPP) + + def copy_to_host(self): + """"Copy data to host""" + if self._type == const.IMAGE_DATA_NUMPY: + data_np = self._data.copy() + return AclLiteImage(data_np, self.width, self.height, 0, 0) + + data = None + mem_type = const.MEMORY_HOST + if AclLiteImage._run_mode == const.ACL_HOST: + if self.is_local(): + data = utils.copy_data_host_to_host(self._data, self.size) + else: + data = utils.copy_data_device_to_host(self._data, self.size) + else: + data = utils.copy_data_device_to_device(self._data, self.size) + mem_type = const.MEMORY_DEVICE + if data is None: + acl_log.log_error("Copy image to host failed") + return None + + return AclLiteImage(data, self.width, self.height, 0, 0, self.size, mem_type) + + def is_local(self): + """Image data is in host server memory and access directly or not""" + # in atlas200dk, all kind memory can access directly + if AclLiteImage._run_mode == const.ACL_DEVICE: + return True + # in atlas300, only acl host memory or numpy array can access directly + elif ((AclLiteImage._run_mode == const.ACL_HOST) and + ((self._memory_type == const.MEMORY_HOST) or + (self._memory_type == const.MEMORY_NORMAL))): + return True + else: + return False + + def save(self, filename): + """Save image as file""" + image_np = self.byte_data_to_np_array() + image_np.tofile(filename) + + def destroy(self): + """Release image memory""" + if (self._data is None) or (self.size == 0): + acl_log.log_error("Release image abnormaly, data is None") + return + + if self._memory_type == const.MEMORY_DEVICE: + acl.rt.free(self._data) + elif self._memory_type == const.MEMORY_HOST: + acl.rt.free_host(self._data) + elif self._memory_type == const.MEMORY_DVPP: + acl.media.dvpp_free(self._data) + # numpy no need release + self._data = None + self.size = 0 + + def __del__(self): + self.destroy() + diff --git a/best_practices/contrib/ganomaly/acllite/acllite_imageproc.py b/best_practices/contrib/ganomaly/acllite/acllite_imageproc.py new file mode 100644 index 0000000000000000000000000000000000000000..e95a9f9bf922a0f3dc15d23004153b180590bb04 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/acllite_imageproc.py @@ -0,0 +1,385 @@ +""" +Copyright (R) @huawei.com, all rights reserved +-*- coding:utf-8 -*- +CREATED: 2021-01-20 20:12:13 +MODIFIED: 2021-01-29 14:04:45 +""" +import numpy as np +import acl +import acllite_utils as utils +from acllite_image import AclLiteImage +from acllite_logger import log_error, log_info +from acllite_resource import resource_list +import constants as constants + +class AclLiteImageProc(object): + """ + dvpp class + """ + + def __init__(self, acl_resource=None): + if acl_resource is None: + self._stream, ret = acl.rt.create_stream() + utils.check_ret("acl.rt.create_stream", ret) + self._run_mode, ret = acl.rt.get_run_mode() + utils.check_ret("acl.rt.get_run_mode", ret) + else: + self._stream = acl_resource.stream + self._run_mode = acl_resource.run_mode + self._dvpp_channel_desc = None + self._crop_config = None + self._paste_config = None + + self._init_resource() + + # AclLiteImageProc involves acl resources, which need to be released \ + # before the acl ends when the program exits, \ + # register here to the resource table to ensure the release timing + self._is_destroyed = False + resource_list.register(self) + + def _init_resource(self): + # Create dvpp channel + self._dvpp_channel_desc = acl.media.dvpp_create_channel_desc() + ret = acl.media.dvpp_create_channel(self._dvpp_channel_desc) + utils.check_ret("acl.media.dvpp_create_channel", ret) + + # Create a resize configuration + self._resize_config = acl.media.dvpp_create_resize_config() + + # Create yuv to jpeg configuration + self._jpege_config = acl.media.dvpp_create_jpege_config() + ret = acl.media.dvpp_set_jpege_config_level(self._jpege_config, 100) + utils.check_ret("acl.media.dvpp_set_jpege_config_level", ret) + + def _gen_input_pic_desc(self, image, + width_align_factor=16, height_align_factor=2): + # Create input image + if image.alignWidth == 0 and image.alignHeight == 0: + image.alignWidth = utils.align_up(image.width, width_align_factor) + image.alignHeight = utils.align_up(image.height, height_align_factor) + + pic_desc = acl.media.dvpp_create_pic_desc() + acl.media.dvpp_set_pic_desc_data(pic_desc, image.data()) + acl.media.dvpp_set_pic_desc_format( + pic_desc, constants.PIXEL_FORMAT_YUV_SEMIPLANAR_420) + acl.media.dvpp_set_pic_desc_width(pic_desc, image.width) + acl.media.dvpp_set_pic_desc_height(pic_desc, image.height) + acl.media.dvpp_set_pic_desc_width_stride(pic_desc, image.alignWidth) + acl.media.dvpp_set_pic_desc_height_stride(pic_desc, image.alignHeight) + acl.media.dvpp_set_pic_desc_size(pic_desc, image.size) + + return pic_desc + + def _gen_output_pic_desc(self, width, height, + output_buffer, output_buffer_size, + width_align_factor=16, height_align_factor=2): + # Create output image + stride_width = utils.align_up(width, width_align_factor) + stride_height = utils.align_up(height, height_align_factor) + + pic_desc = acl.media.dvpp_create_pic_desc() + acl.media.dvpp_set_pic_desc_data(pic_desc, output_buffer) + acl.media.dvpp_set_pic_desc_format( + pic_desc, constants.PIXEL_FORMAT_YUV_SEMIPLANAR_420) + acl.media.dvpp_set_pic_desc_width(pic_desc, width) + acl.media.dvpp_set_pic_desc_height(pic_desc, height) + acl.media.dvpp_set_pic_desc_width_stride(pic_desc, stride_width) + acl.media.dvpp_set_pic_desc_height_stride(pic_desc, stride_height) + acl.media.dvpp_set_pic_desc_size(pic_desc, output_buffer_size) + + return pic_desc + + def _stride_yuv_size(self, width, height, + width_align_factor=16, height_align_factor=2): + stride_width = utils.align_up(width, width_align_factor) + stride_height = utils.align_up(height, height_align_factor) + stride_size = utils.yuv420sp_size(stride_width, stride_height) + + return stride_width, stride_height, stride_size + + def jpegd(self, image): + """ + jepg image to yuv image + """ + stride_width = utils.align_up128(image.width) + stride_height = utils.align_up16(image.height) + stride_size = utils.yuv420sp_size(stride_width, stride_height) + # Create conversion output image desc + output_desc, out_buffer = self._gen_jpegd_out_pic_desc(image, stride_size) + ret = acl.media.dvpp_jpeg_decode_async(self._dvpp_channel_desc, + image.data(), + image.size, + output_desc, + self._stream) + if ret != constants.ACL_SUCCESS: + log_error("dvpp_jpeg_decode_async failed ret={}".format(ret)) + return None + + ret = acl.rt.synchronize_stream(self._stream) + if ret != constants.ACL_SUCCESS: + log_error("dvpp_jpeg_decode_async failed ret={}".format(ret)) + return None + + # Return the decoded AclLiteImage instance + return AclLiteImage(out_buffer, image.width, image.height, stride_width, + stride_height, stride_size, constants.MEMORY_DVPP) + + def _gen_jpegd_out_pic_desc(self, image, stride_size): + # Predict the memory size required to decode jpeg into yuv pictures + ret, out_buffer_size = self._get_jpegd_memory_size(image, stride_size) + if not ret: + return None + # Apply for memory for storing decoded yuv pictures + out_buffer, ret = acl.media.dvpp_malloc(out_buffer_size) + if ret != constants.ACL_SUCCESS: + log_error("AclLiteImageProc malloc failed, error: ", ret) + return None + # Create output image desc + pic_desc = self._gen_output_pic_desc( + image.width, + image.height, + out_buffer, + out_buffer_size, + width_align_factor=128, + height_align_factor=16) + return pic_desc, out_buffer + + def _get_jpegd_memory_size(self, image, stride_size): + if image.is_local(): + size, ret = acl.media.dvpp_jpeg_predict_dec_size( + image.data(), image.size, constants.PIXEL_FORMAT_YUV_SEMIPLANAR_420) + if ret != constants.ACL_SUCCESS: + log_error("Predict jpeg decode size failed, return ", ret) + return False, 0 + return True, size + else: + return True, int(stride_size) + + def resize(self, image, resize_width, resize_height): + """ + Scale yuvsp420 picture to specified size + """ + # Generate input picture desc + input_desc = self._gen_input_pic_desc(image) + # Calculate the image size after scaling + stride_width = utils.align_up16(resize_width) + stride_height = utils.align_up2(resize_height) + output_size = utils.yuv420sp_size(stride_width, stride_height) + # Request memory for the zoomed picture + out_buffer, ret = acl.media.dvpp_malloc(output_size) + if ret != constants.ACL_SUCCESS: + log_error("AclLiteImageProc malloc failed, error: ", ret) + return None + # Create output image + output_desc = self._gen_output_pic_desc(resize_width, resize_height, + out_buffer, output_size) + if output_desc is None: + log_error("Gen resize output desc failed") + return None + # Call dvpp asynchronous zoom interface to zoom pictures + ret = acl.media.dvpp_vpc_resize_async(self._dvpp_channel_desc, + input_desc, + output_desc, + self._resize_config, + self._stream) + if ret != constants.ACL_SUCCESS: + log_error("Vpc resize async failed, error: ", ret) + return None + # Wait for the zoom operation to complete + ret = acl.rt.synchronize_stream(self._stream) + if ret != constants.ACL_SUCCESS: + log_error("Resize synchronize stream failed, error: ", ret) + return None + # Release the resources requested for scaling + acl.media.dvpp_destroy_pic_desc(input_desc) + acl.media.dvpp_destroy_pic_desc(output_desc) + return AclLiteImage(out_buffer, resize_width, resize_height, stride_width, + stride_height, output_size, constants.MEMORY_DVPP) + + def _gen_resize_out_pic_desc(self, resize_width, + resize_height, output_size): + out_buffer, ret = acl.media.dvpp_malloc(output_size) + if ret != constants.ACL_SUCCESS: + log_error("AclLiteImageProc malloc failed, error: ", ret) + return None + pic_desc = self._gen_output_pic_desc(resize_width, resize_height, + out_buffer, output_size) + return pic_desc, out_buffer + + def crop_and_paste( + self, + image, + width, + height, + crop_and_paste_width, + crop_and_paste_height): + """ + crop_and_paste + """ + print('[AclLiteImageProc] vpc crop and paste stage:') + input_desc = self._gen_input_pic_desc(image) + stride_width = utils.align_up16(crop_and_paste_width) + stride_height = utils.align_up2(crop_and_paste_height) + out_buffer_size = utils.yuv420sp_size(stride_width, stride_height) + out_buffer, ret = acl.media.dvpp_malloc(out_buffer_size) + output_desc = self._gen_output_pic_desc( + crop_and_paste_width, + crop_and_paste_height, + out_buffer, + out_buffer_size) + self._crop_config = acl.media.dvpp_create_roi_config( + 0, (width >> 1 << 1) - 1, 0, (height >> 1 << 1) - 1) + # set crop area: + rx = float(width) / float(crop_and_paste_width) + ry = float(height) / float(crop_and_paste_height) + if rx > ry: + dx = 0 + r = rx + dy = int((crop_and_paste_height - height / r) / 2) + else: + dy = 0 + r = ry + dx = int((crop_and_paste_width - width / r) / 2) + pasteRightOffset = int(crop_and_paste_width - 2 * dx) + pasteBottomOffset = int(crop_and_paste_height - 2 * dy) + if (pasteRightOffset % 2) == 0: + pasteRightOffset = pasteRightOffset - 1 + if (pasteBottomOffset % 2) == 0: + pasteBottomOffset = pasteBottomOffset - 1 + self._paste_config = acl.media.dvpp_create_roi_config( + 0, pasteRightOffset, 0, pasteBottomOffset) + ret = acl.media.dvpp_vpc_crop_and_paste_async(self._dvpp_channel_desc, + input_desc, + output_desc, + self._crop_config, + self._paste_config, + self._stream) + utils.check_ret("acl.media.dvpp_vpc_crop_and_paste_async", ret) + ret = acl.rt.synchronize_stream(self._stream) + utils.check_ret("acl.rt.synchronize_stream", ret) + print('[AclLiteImageProc] vpc crop and paste stage success') + stride_width = crop_and_paste_width - 2 * dx + stride_height = crop_and_paste_height - 2 * dy + acl.media.dvpp_destroy_pic_desc(input_desc) + acl.media.dvpp_destroy_pic_desc(output_desc) + + return AclLiteImage(out_buffer, image.width, image.height, stride_width, + stride_height, out_buffer_size, constants.MEMORY_DVPP) + + def crop_and_paste_get_roi( + self, + image, + width, + height, + crop_and_paste_width, + crop_and_paste_height): + """ + :image: input image + :width: input image width + :height: input image height + :crop_and_paste_width: crop_and_paste_width + :crop_and_paste_height: crop_and_paste_height + :return: return AclLiteImage + """ + print('[AclLiteImageProc] vpc crop and paste stage:') + input_desc = self._gen_input_pic_desc(image) + stride_width = utils.align_up16(crop_and_paste_width) + stride_height = utils.align_up2(crop_and_paste_height) + out_buffer_size = utils.yuv420sp_size(stride_width, stride_height) + out_buffer, ret = acl.media.dvpp_malloc(out_buffer_size) + output_desc = self._gen_output_pic_desc( + crop_and_paste_width, + crop_and_paste_height, + out_buffer, + out_buffer_size) + self._crop_config = acl.media.dvpp_create_roi_config( + 0, (width >> 1 << 1) - 1, 0, (height >> 1 << 1) - 1) + self._paste_config = acl.media.dvpp_create_roi_config( + 0, crop_and_paste_width - 1, 0, crop_and_paste_height - 1) + ret = acl.media.dvpp_vpc_crop_and_paste_async(self._dvpp_channel_desc, + input_desc, + output_desc, + self._crop_config, + self._paste_config, + self._stream) + utils.check_ret("acl.media.dvpp_vpc_crop_and_paste_async", ret) + ret = acl.rt.synchronize_stream(self._stream) + utils.check_ret("acl.rt.synchronize_stream", ret) + print('[AclLiteImageProc] vpc crop and paste stage success') + stride_width = utils.align_up16(crop_and_paste_width) + stride_height = utils.align_up2(crop_and_paste_height) + acl.media.dvpp_destroy_pic_desc(input_desc) + acl.media.dvpp_destroy_pic_desc(output_desc) + return AclLiteImage(out_buffer, image.width, image.height, stride_width, + stride_height, out_buffer_size, constants.MEMORY_DVPP) + + def jpege(self, image): + """ + Convert yuv420sp pictures to jpeg pictures + """ + # create input image + input_desc = self._gen_input_pic_desc(image) + # Predict the memory size required for conversion + output_size, ret = acl.media.dvpp_jpeg_predict_enc_size( + input_desc, self._jpege_config) + if (ret != constants.ACL_SUCCESS): + log_error("Predict jpege output size failed") + return None + # Request memory required for conversion + output_buffer, ret = acl.media.dvpp_malloc(output_size) + if (ret != constants.ACL_SUCCESS): + log_error("Malloc jpege output memory failed") + return None + output_size_array = np.array([output_size], dtype=np.int32) + if "bytes_to_ptr" in dir(acl.util): + bytes_data = output_size_array.tobytes() + output_size_ptr = acl.util.bytes_to_ptr(bytes_data) + else: + output_size_ptr = acl.util.numpy_to_ptr(output_size_array) + + # Call jpege asynchronous interface to convert pictures + ret = acl.media.dvpp_jpeg_encode_async(self._dvpp_channel_desc, + input_desc, output_buffer, + output_size_ptr, + self._jpege_config, + self._stream) + if (ret != constants.ACL_SUCCESS): + log_error("Jpege failed, ret ", ret) + return None + # Wait for the conversion to complete + ret = acl.rt.synchronize_stream(self._stream) + if (ret != constants.ACL_SUCCESS): + print("Jpege synchronize stream, failed, ret ", ret) + return None + # Release resources + acl.media.dvpp_destroy_pic_desc(input_desc) + if "bytes_to_ptr" in dir(acl.util): + output_size_array=np.frombuffer(bytes_data,dtype=output_size_array.dtype).reshape(output_size_array.shape) + return AclLiteImage( + output_buffer, image.width, image.height, 0, 0, int( + output_size_array[0]), constants.MEMORY_DVPP) + + def destroy(self): + """ + dvpp resource release + """ + if self._is_destroyed: + return + + if self._resize_config: + acl.media.dvpp_destroy_resize_config(self._resize_config) + + if self._dvpp_channel_desc: + acl.media.dvpp_destroy_channel(self._dvpp_channel_desc) + acl.media.dvpp_destroy_channel_desc(self._dvpp_channel_desc) + + if self._jpege_config: + acl.media.dvpp_destroy_jpege_config(self._jpege_config) + self._is_destroyed = True + resource_list.unregister(self) + log_info("dvpp resource release success") + + def __del__(self): + self.destroy() + diff --git a/best_practices/contrib/ganomaly/acllite/acllite_logger.py b/best_practices/contrib/ganomaly/acllite/acllite_logger.py new file mode 100644 index 0000000000000000000000000000000000000000..2f3b79b43cf652273ff9562f6c152befc14b6bd2 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/acllite_logger.py @@ -0,0 +1,92 @@ +import sys +import os + +import acl + +_ACL_DEBUG = 0 +_ACL_INFO = 1 +_ACL_WARNING = 2 +_ACL_ERROR = 3 + +def log_error(*log_msg): + """Recode error level log to file + Args: + *log_msg: format string and args list + """ + log_str = [str(i) for i in log_msg] + log_str = "".join(log_str) + + print(log_str) + + caller_frame = sys._getframe().f_back + # caller file + filename = caller_frame.f_code.co_filename + # caller line no + line_no = caller_frame.f_lineno + # caller function + func_name = caller_frame.f_code.co_name + + message = "[" + filename + ":" + str(line_no) + \ + " " + func_name + "]" + log_str + acl.app_log(_ACL_ERROR, message) + +def log_warning(*log_msg): + """Recode warning level log to file + Args: + *log_msg: format string and args list + """ + log_str = [str(i) for i in log_msg] + log_str = "[WARNING]"+"".join(log_str) + + print(log_str) + + caller_frame = sys._getframe().f_back + # caller file + filename = caller_frame.f_code.co_filename + # caller line no + line_no = caller_frame.f_lineno + # caller function + func_name = caller_frame.f_code.co_name + + message = "[" + filename + ":" + str(line_no) + \ + " " + func_name + "]" + log_str + acl.app_log(_ACL_WARNING, message) + +def log_info(*log_msg): + """Recode info level log to file + Args: + *log_msg: format string and args list + """ + log_str = [str(i) for i in log_msg] + log_str = "".join(log_str) + print(log_str) + caller_frame = sys._getframe().f_back + # caller file + filename = caller_frame.f_code.co_filename + # caller line no + line_no = caller_frame.f_lineno + # caller function + func_name = caller_frame.f_code.co_name + + message = "[" + filename + ":" + str(line_no) + \ + " " + func_name + "]" + log_str + acl.app_log(_ACL_INFO, message) + +def log_debug(*log_msg): + """Recode debug level log to file + Args: + *log_msg: format string and args list + """ + log_str = [str(i) for i in log_msg] + log_str = "".join(log_str) + caller_frame = sys._getframe().f_back + # caller file + filename = caller_frame.f_code.co_filename + # caller line no + line_no = caller_frame.f_lineno + # caller function + func_name = caller_frame.f_code.co_name + + message = "[" + filename + ":" + str(line_no) + \ + " " + func_name + "]" + log_str + acl.app_log(_ACL_DEBUG, message) diff --git a/best_practices/contrib/ganomaly/acllite/acllite_model.py b/best_practices/contrib/ganomaly/acllite/acllite_model.py new file mode 100644 index 0000000000000000000000000000000000000000..766f2727f0e92a2de781f638d1bf48ea8deb73b7 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/acllite_model.py @@ -0,0 +1,445 @@ +""" +Copyright (R) @huawei.com, all rights reserved +-*- coding:utf-8 -*- +CREATED: 2020-6-04 20:12:13 +MODIFIED: 2020-6-28 14:04:45 +""" +import acl +import struct +import numpy as np +import datetime +import sys +import os + +import constants as const +import acllite_utils as utils +from acllite_logger import log_error, log_info, log_warning +from acllite_image import AclLiteImage +from acllite_resource import resource_list + +class AclLiteModel(object): + """ + wrap acl model inference interface, include input dataset construction, + execute, and output transform to numpy array + Attributes: + model_path: om offline mode file path + """ + + def __init__(self, model_path, load_type=0): + self._run_mode, ret = acl.rt.get_run_mode() + utils.check_ret("acl.rt.get_run_mode", ret) + self._copy_policy = const.ACL_MEMCPY_DEVICE_TO_DEVICE + if self._run_mode == const.ACL_HOST: + self._copy_policy = const.ACL_MEMCPY_DEVICE_TO_HOST + + self._model_path = model_path # string + self._load_type = load_type + self._model_id = None # pointer + self._input_num = 0 + self._input_buffer = [] + self._input_dataset = None + self._output_dataset = None + self._model_desc = None # pointer when using + self._output_size = 0 + self._init_resource() + self._is_destroyed = False + resource_list.register(self) + + def _init_resource(self): + log_info("Init model resource start...") + if not os.path.isfile(self._model_path): + log_error( + "model_path failed, please check. model_path=%s" % + self._model_path) + return const.FAILED + + if self._load_type == 0: + self._model_id, ret = acl.mdl.load_from_file(self._model_path) + utils.check_ret("acl.mdl.load_from_file", ret) + elif self._load_type == 1: + with open(self._model_path, "rb") as f: + om_bytes = f.read() + if om_bytes: + ptr = acl.util.bytes_to_ptr(om_bytes) + self._model_id, ret = acl.mdl.load_from_mem(ptr, len(om_bytes)) + utils.check_ret("acl.mdl.load_from_mem", ret) + else: + log_error( + "model_context is null, please check. model_path=%s" % + self._model_path) + return const.FAILED + else: + log_error( + "load_type is not in 0 or 1, please check. load_type=%d" % + self._load_type) + return const.FAILED + self._model_desc = acl.mdl.create_desc() + ret = acl.mdl.get_desc(self._model_desc, self._model_id) + utils.check_ret("acl.mdl.get_desc", ret) + # get outputs num of model + self._output_size = acl.mdl.get_num_outputs(self._model_desc) + # create output dataset + self._gen_output_dataset(self._output_size) + # recode input data address,if need malloc memory,the memory will be + # reuseable + self._init_input_buffer() + log_info("Init model resource success") + + return const.SUCCESS + + def _gen_output_dataset(self, ouput_num): + log_info("[AclLiteModel] create model output dataset:") + dataset = acl.mdl.create_dataset() + for i in range(ouput_num): + # malloc device memory for output + size = acl.mdl.get_output_size_by_index(self._model_desc, i) + buf, ret = acl.rt.malloc(size, const.ACL_MEM_MALLOC_NORMAL_ONLY) + utils.check_ret("acl.rt.malloc", ret) + # crate oputput data buffer + dataset_buffer = acl.create_data_buffer(buf, size) + _, ret = acl.mdl.add_dataset_buffer(dataset, dataset_buffer) + log_info("malloc output %d, size %d" % (i, size)) + if ret: + acl.rt.free(buf) + acl.destroy_data_buffer(dataset_buffer) + utils.check_ret("acl.destroy_data_buffer", ret) + self._output_dataset = dataset + log_info("Create model output dataset success") + + def _init_input_buffer(self): + self._input_num = acl.mdl.get_num_inputs(self._model_desc) + for i in range(self._input_num): + item = {"addr": None, "size": 0} + self._input_buffer.append(item) + + def _gen_input_dataset(self, input_list): + dynamicIdx, ret = acl.mdl.get_input_index_by_name(self._model_desc, "ascend_mbatch_shape_data") + if ret == const.ACL_SUCCESS: + dataLen = acl.mdl.get_input_size_by_index(self._model_desc, dynamicIdx) + buf, ret = acl.rt.malloc(dataLen, const.ACL_MEM_MALLOC_NORMAL_ONLY) + utils.check_ret("acl.rt.malloc", ret) + batch_buffer = {'data': buf, 'size':dataLen} + input_list.append(batch_buffer) + + ret = const.SUCCESS + if len(input_list) != self._input_num: + log_error("Current input data num %d unequal to model " + "input num %d" % (len(input_list), self._input_num)) + return const.FAILED + + self._input_dataset = acl.mdl.create_dataset() + for i in range(self._input_num): + item = input_list[i] + data, size = self._parse_input_data(item, i) + if (data is None) or (size == 0): + ret = const.FAILED + log_error("The %d input is invalid" % (i)) + break + + model_size = acl.mdl.get_input_size_by_index(self._model_desc, i) + if size != model_size: + log_warning(" Input[%d] size: %d not equal om size: %d" % (i, size, model_size) +\ + ", may cause inference result error, please check model input") + + + dataset_buffer = acl.create_data_buffer(data, size) + _, ret = acl.mdl.add_dataset_buffer(self._input_dataset, + dataset_buffer) + if ret: + log_error("Add input dataset buffer failed") + acl.destroy_data_buffer(self._input_dataset) + ret = const.FAILED + break + if ret == const.FAILED: + self._release_dataset(self._input_dataset) + self._input_dataset = None + + return ret + + def _parse_input_data(self, input_data, index): + data = None + size = 0 + if isinstance(input_data, AclLiteImage): + size = input_data.size + data = input_data.data() + elif isinstance(input_data, np.ndarray): + size = input_data.size * input_data.itemsize + if "bytes_to_ptr" in dir(acl.util): + bytes_data=input_data.tobytes() + ptr=acl.util.bytes_to_ptr(bytes_data) + else: + ptr = acl.util.numpy_to_ptr(input_data) + data = self._copy_input_to_device(ptr, size, index) + if data is None: + size = 0 + log_error("Copy input to device failed") + elif (isinstance(input_data, dict) and + ('data' in input_data.keys()) and ('size' in input_data.keys())): + size = input_data['size'] + data = input_data['data'] + else: + log_error("Unsupport input") + + return data, size + + def _copy_input_to_device(self, input_ptr, size, index): + buffer_item = self._input_buffer[index] + data = None + if buffer_item['addr'] is None: + if self._run_mode == const.ACL_HOST: + data = utils.copy_data_host_to_device(input_ptr, size) + else: + data = utils.copy_data_device_to_device(input_ptr, size) + if data is None: + log_error("Malloc memory and copy model %dth " + "input to device failed" % (index)) + return None + buffer_item['addr'] = data + buffer_item['size'] = size + elif size == buffer_item['size']: + if self._run_mode == const.ACL_HOST: + ret = acl.rt.memcpy(buffer_item['addr'], size, + input_ptr, size, + const.ACL_MEMCPY_HOST_TO_DEVICE) + else: + ret = acl.rt.memcpy(buffer_item['addr'], size, + input_ptr, size, + const.ACL_MEMCPY_DEVICE_TO_DEVICE) + if ret != const.ACL_SUCCESS: + log_error("Copy model %dth input to device failed" % (index)) + return None + data = buffer_item['addr'] + else: + log_error("The model %dth input size %d is change," + " before is %d" % (index, size, buffer_item['size'])) + return None + + return data + + def _set_dynamic_batch_size(self, batch): + dynamicIdx, ret = acl.mdl.get_input_index_by_name(self._model_desc, "ascend_mbatch_shape_data") + if ret != const.ACL_SUCCESS: + log_error("get_input_index_by_name failed") + return const.FAILED + batch_dic, ret = acl.mdl.get_dynamic_batch(self._model_desc) + if ret != const.ACL_SUCCESS: + log_error("get_dynamic_batch failed") + return const.FAILED + print("[INFO] get dynamic_batch = ", batch_dic) + ret = acl.mdl.set_dynamic_batch_size(self._model_id, self._input_dataset, dynamicIdx, batch) + if ret != const.ACL_SUCCESS: + log_error("set_dynamic_batch_size failed, ret = ", ret) + return const.FAILED + if batch in batch_dic["batch"]: + return const.SUCCESS + else: + assert ret == ACL_ERROR_GE_DYNAMIC_BATCH_SIZE_INVALID + print("[INFO] [dynamic batch] {} is not in {}".format(batch, batch_dic["batch"])) + return const.FAILED + + def _execute_with_dynamic_batch_size(self, input_list, batch): + ret = self._gen_input_dataset(input_list) + if ret == const.FAILED: + log_error("Gen model input dataset failed") + return None + + ret = self._set_dynamic_batch_size(batch) + if ret == const.FAILED: + log_error("Set dynamic batch failed") + return None + + ret = acl.mdl.execute(self._model_id, + self._input_dataset, + self._output_dataset) + if ret != const.ACL_SUCCESS: + log_error("Execute model failed for acl.mdl.execute error ", ret) + return None + + self._release_dataset(self._input_dataset) + self._input_dataset = None + + return self._output_dataset_to_numpy() + + def execute(self, input_list): + """ + inference input data + Args: + input_list: input data list, support AclLiteImage, + numpy array and {'data': ,'size':} dict + returns: + inference result data, which is a numpy array list, + each corresponse to a model output + """ + ret = self._gen_input_dataset(input_list) + if ret == const.FAILED: + log_error("Gen model input dataset failed") + return None + + ret = acl.mdl.execute(self._model_id, + self._input_dataset, + self._output_dataset) + if ret != const.ACL_SUCCESS: + log_error("Execute model failed for acl.mdl.execute error ", ret) + return None + + self._release_dataset(self._input_dataset) + self._input_dataset = None + + return self._output_dataset_to_numpy() + + def _output_dataset_to_numpy(self): + dataset = [] + output_tensor_list = self._gen_output_tensor() + num = acl.mdl.get_dataset_num_buffers(self._output_dataset) + + for i in range(num): + buf = acl.mdl.get_dataset_buffer(self._output_dataset, i) + data = acl.get_data_buffer_addr(buf) + size = int(acl.get_data_buffer_size(buf)) + output_ptr = output_tensor_list[i]["ptr"] + output_data = output_tensor_list[i]["tensor"] + if isinstance (output_data,bytes): + data_size = len(output_data) + else: + data_size = output_data.size * output_data.itemsize + ret = acl.rt.memcpy(output_ptr, + data_size, + data, size, self._copy_policy) + if ret != const.ACL_SUCCESS: + log_error("Memcpy inference output to local failed") + return None + + if isinstance (output_data,bytes): + output_data = np.frombuffer(output_data, dtype=output_tensor_list[i]["dtype"]).reshape(output_tensor_list[i]["shape"]) + output_tensor = output_data.copy() + else: + output_tensor = output_data + dataset.append(output_tensor) + + return dataset + + def _gen_output_tensor(self): + output_tensor_list = [] + for i in range(self._output_size): + dims = acl.mdl.get_output_dims(self._model_desc, i) + shape = tuple(dims[0]["dims"]) + datatype = acl.mdl.get_output_data_type(self._model_desc, i) + size = acl.mdl.get_output_size_by_index(self._model_desc, i) + + if datatype == const.ACL_FLOAT: + np_type = np.float32 + output_tensor = np.zeros( + size // 4, dtype=np_type).reshape(shape) + elif datatype == const.ACL_DOUBLE: + np_type = np.float64 + output_tensor = np.zeros( + size // 8, dtype=np_type).reshape(shape) + elif datatype == const.ACL_INT64: + np_type = np.int64 + output_tensor = np.zeros( + size // 8, dtype=np_type).reshape(shape) + elif datatype == const.ACL_UINT64: + np_type = np.uint64 + output_tensor = np.zeros( + size // 8, dtype=np_type).reshape(shape) + elif datatype == const.ACL_INT32: + np_type = np.int32 + output_tensor = np.zeros( + size // 4, dtype=np_type).reshape(shape) + elif datatype == const.ACL_UINT32: + np_type = np.uint32 + output_tensor = np.zeros( + size // 4, dtype=np_type).reshape(shape) + elif datatype == const.ACL_FLOAT16: + np_type = np.float16 + output_tensor = np.zeros( + size // 2, dtype=np_type).reshape(shape) + elif datatype == const.ACL_INT16: + np_type = np.int16 + output_tensor = np.zeros( + size // 2, dtype=np_type).reshape(shape) + elif datatype == const.ACL_UINT16: + np_type = np.uint16 + output_tensor = np.zeros( + size // 2, dtype=np_type).reshape(shape) + elif datatype == const.ACL_INT8: + np_type = np.int8 + output_tensor = np.zeros( + size, dtype=np_type).reshape(shape) + elif datatype == const.ACL_BOOL or datatype == const.ACL_UINT8: + np_type = np.uint8 + output_tensor = np.zeros( + size, dtype=np_type).reshape(shape) + else: + print("Unspport model output datatype ", datatype) + return None + + if not output_tensor.flags['C_CONTIGUOUS']: + output_tensor = np.ascontiguousarray(output_tensor) + + if "bytes_to_ptr" in dir(acl.util): + bytes_data=output_tensor.tobytes() + tensor_ptr=acl.util.bytes_to_ptr(bytes_data) + output_tensor_list.append({"ptr": tensor_ptr, + "tensor": bytes_data, + "shape":output_tensor.shape, + "dtype":output_tensor.dtype},) + else: + tensor_ptr = acl.util.numpy_to_ptr(output_tensor) + output_tensor_list.append({"ptr": tensor_ptr, + "tensor": output_tensor}) + + return output_tensor_list + + def _release_dataset(self, dataset, free_memory=False): + if not dataset: + return + + num = acl.mdl.get_dataset_num_buffers(dataset) + for i in range(num): + data_buf = acl.mdl.get_dataset_buffer(dataset, i) + if data_buf: + self._release_databuffer(data_buf, free_memory) + + ret = acl.mdl.destroy_dataset(dataset) + if ret != const.ACL_SUCCESS: + log_error("Destroy data buffer error ", ret) + + def _release_databuffer(self, data_buffer, free_memory=False): + if free_memory: + data_addr = acl.get_data_buffer_addr(data_buffer) + if data_addr: + acl.rt.free(data_addr) + + ret = acl.destroy_data_buffer(data_buffer) + if ret != const.ACL_SUCCESS: + log_error("Destroy data buffer error ", ret) + + def destroy(self): + """ + release resource of model inference + Args: + null + Returns: + null + """ + if self._is_destroyed: + return + + self._release_dataset(self._output_dataset, free_memory=True) + if self._model_id: + ret = acl.mdl.unload(self._model_id) + if ret != const.ACL_SUCCESS: + log_info("acl.mdl.unload error:", ret) + + if self._model_desc: + ret = acl.mdl.destroy_desc(self._model_desc) + if ret != const.ACL_SUCCESS: + log_info("acl.mdl.destroy_desc error:", ret) + + self._is_destroyed = True + resource_list.unregister(self) + log_info("AclLiteModel release source success") + + def __del__(self): + self.destroy() diff --git a/best_practices/contrib/ganomaly/acllite/acllite_resource.py b/best_practices/contrib/ganomaly/acllite/acllite_resource.py new file mode 100644 index 0000000000000000000000000000000000000000..7490c732ff3091ebe1674a06f66b47128e02a13f --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/acllite_resource.py @@ -0,0 +1,110 @@ +""" +Copyright (R) @huawei.com, all rights reserved +-*- coding:utf-8 -*- +CREATED: 2021-01-20 20:12:13 +MODIFIED: 2021-02-03 14:04:45 +""" +import threading +import acl + +import acllite_utils as utils + +REGISTER = 0 +UNREGISTER = 1 + +class _ResourceList(object): + """Acl resources of current application + This class provide register inferace of acl resource, when application + exit, all register resource will release befor acl.rt.reset_device to + avoid program abnormal + """ + _instance_lock = threading.Lock() + + def __init__(self): + self.resources = [] + + def __new__(cls, *args, **kwargs): + if not hasattr(_ResourceList, "_instance"): + with _ResourceList._instance_lock: + if not hasattr(_ResourceList, "_instance"): + _ResourceList._instance = object.__new__( + cls, *args, **kwargs) + return _ResourceList._instance + + def register(self, resource): + """Resource register interface + Args: + resource: object with acl resource, the object must be has + method destroy() + """ + item = {"resource": resource, "status": REGISTER} + self.resources.append(item) + + def unregister(self, resource): + """Resource unregister interface + If registered resource release by self and no need _ResourceList + release, the resource object should unregister self + Args: + resource: registered resource + """ + for item in self.resources: + if resource == item["resource"]: + item["status"] = UNREGISTER + + def destroy(self): + """Destroy all register resource""" + for item in self.resources: + if item["status"] == REGISTER: + item["resource"].destroy() + item["status"] = UNREGISTER + +resource_list = _ResourceList() + +class AclLiteResource(object): + """ + AclLiteResource + """ + + def __init__(self, device_id=0): + self.device_id = device_id + self.context = None + self.stream = None + self.run_mode = None + + def init(self): + """ + init resource + """ + print("init resource stage:") + ret = acl.init() + utils.check_ret("acl.init", ret) + + ret = acl.rt.set_device(self.device_id) + utils.check_ret("acl.rt.set_device", ret) + + self.context, ret = acl.rt.create_context(self.device_id) + utils.check_ret("acl.rt.create_context", ret) + + self.stream, ret = acl.rt.create_stream() + utils.check_ret("acl.rt.create_stream", ret) + + self.run_mode, ret = acl.rt.get_run_mode() + utils.check_ret("acl.rt.get_run_mode", ret) + + print("Init resource success") + + def __del__(self): + print("acl resource release all resource") + resource_list.destroy() + if self.stream: + print("acl resource release stream") + acl.rt.destroy_stream(self.stream) + + if self.context: + print("acl resource release context") + acl.rt.destroy_context(self.context) + + print("Reset acl device ", self.device_id) + acl.rt.reset_device(self.device_id) + acl.finalize() + print("Release acl resource success") diff --git a/best_practices/contrib/ganomaly/acllite/acllite_utils.py b/best_practices/contrib/ganomaly/acllite/acllite_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..1e71cc21e5d7473724bec91c00ac4053ca5bbe3a --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/acllite_utils.py @@ -0,0 +1,252 @@ +import numpy as np +import acl +import constants as const +from acllite_logger import log_error, log_info +import time + +from functools import wraps +DEBUG = True + +def check_ret(message, ret_int): + """Check int value is 0 or not + Args: + message: output log str + ret_int: check value that type is int + """ + if ret_int != 0: + raise Exception("{} failed ret_int={}" + .format(message, ret_int)) + +def check_none(message, ret_none): + """Check object is None or not + Args: + message: output log str + ret_none: check object + """ + if ret_none is None: + raise Exception("{} failed" + .format(message)) + +def copy_data_device_to_host(device_data, data_size): + """Copy device data to host + Args: + device_data: data that to be copyed + data_size: data size + Returns: + None: copy failed + others: host data which copy from device_data + """ + host_buffer, ret = acl.rt.malloc_host(data_size) + if ret != const.ACL_SUCCESS: + log_error("Malloc host memory failed, error: ", ret) + return None + + ret = acl.rt.memcpy(host_buffer, data_size, + device_data, data_size, + const.ACL_MEMCPY_DEVICE_TO_HOST) + if ret != const.ACL_SUCCESS: + log_error("Copy device data to host memory failed, error: ", ret) + acl.rt.free_host(host_buffer) + return None + + return host_buffer + +def copy_data_device_to_device(device_data, data_size): + """Copy device data to device + Args: + device_data: data that to be copyed + data_size: data size + Returns: + None: copy failed + others: device data which copy from device_data + """ + device_buffer, ret = acl.rt.malloc(data_size, + const.ACL_MEM_MALLOC_NORMAL_ONLY) + if ret != const.ACL_SUCCESS: + log_error("Malloc device memory failed, error: ", ret) + return None + + ret = acl.rt.memcpy(device_buffer, data_size, + device_data, data_size, + const.ACL_MEMCPY_DEVICE_TO_DEVICE) + if ret != const.ACL_SUCCESS: + log_error("Copy device data to device memory failed, error: ", ret) + acl.rt.free(device_buffer) + return None + + return device_buffer + +def copy_data_host_to_device(host_data, data_size): + """Copy host data to device + Args: + host_data: data that to be copyed + data_size: data size + Returns: + None: copy failed + others: device data which copy from host_data + """ + device_buffer, ret = acl.rt.malloc(data_size, + const.ACL_MEM_MALLOC_NORMAL_ONLY) + if ret != const.ACL_SUCCESS: + log_error("Malloc device memory failed, error: ", ret) + return None + + ret = acl.rt.memcpy(device_buffer, data_size, + host_data, data_size, + const.ACL_MEMCPY_HOST_TO_DEVICE) + if ret != const.ACL_SUCCESS: + log_error("Copy device data to device memory failed, error: ", ret) + acl.rt.free(device_buffer) + return None + + return device_buffer + +def copy_data_host_to_host(host_data, data_size): + """Copy host data to host + Args: + host_data: data that to be copyed + data_size: data size + Returns: + None: copy failed + others: host data which copy from host_data + """ + host_buffer, ret = acl.rt.malloc_host(data_size) + if ret != const.ACL_SUCCESS: + log_error("Malloc host memory failed, error: ", ret) + return None + + ret = acl.rt.memcpy(host_buffer, data_size, + host_data, data_size, + const.ACL_MEMCPY_HOST_TO_HOST) + if ret != const.ACL_SUCCESS: + log_error("Copy host data to host memory failed, error: ", ret) + acl.rt.free_host(host_buffer) + return None + + return host_buffer + +def copy_data_to_dvpp(data, size, run_mode): + """Copy data to dvpp + Args: + data: data that to be copyed + data_size: data size + run_mode: device run mode + Returns: + None: copy failed + others: data which copy from host_data + """ + policy = const.ACL_MEMCPY_HOST_TO_DEVICE + if run_mode == const.ACL_DEVICE: + policy = const.ACL_MEMCPY_DEVICE_TO_DEVICE + + dvpp_buf, ret = acl.media.dvpp_malloc(size) + check_ret("acl.rt.malloc_host", ret) + + ret = acl.rt.memcpy(dvpp_buf, size, data, size, policy) + check_ret("acl.rt.memcpy", ret) + + return dvpp_buf + +def copy_data_as_numpy(data, size, data_mem_type, run_mode): + """Copy data as numpy array + Args: + data: data that to be copyed + size: data size + data_mem_type: src data memory type + run_mode: device run mode + Returns: + None: copy failed + others: numpy array whoes data copy from host_data + """ + np_data = np.zeros(size, dtype=np.byte) + if "bytes_to_ptr" in dir(acl.util): + bytes_data=np_data.tobytes() + np_data_ptr=acl.util.bytes_to_ptr(bytes_data) + else: + np_data_ptr = acl.util.numpy_to_ptr(np_data) + + policy = const.ACL_MEMCPY_DEVICE_TO_DEVICE + if run_mode == const.ACL_HOST: + if ((data_mem_type == const.MEMORY_DEVICE) or + (data_mem_type == const.MEMORY_DVPP)): + policy = const.ACL_MEMCPY_DEVICE_TO_HOST + elif data_mem_type == const.MEMORY_HOST: + policy = const.ACL_MEMCPY_HOST_TO_HOST + + ret = acl.rt.memcpy(np_data_ptr, size, data, size, policy) + check_ret("acl.rt.memcpy", ret) + if "bytes_to_ptr" in dir(acl.util): + np_data=np.frombuffer(bytes_data,dtype=np_data.dtype).reshape(np_data.shape) + return np_data + +def align_up(value, align): + """Align up int value + Args: + value:input data + align: align data + Return: + aligned data + """ + return int(int((value + align - 1) / align) * align) + +def align_up16(value): + """Align up data with 16 + Args: + value:input data + Returns: + 16 aligned data + """ + return align_up(value, 16) + +def align_up128(value): + """Align up data with 128 + Args: + value:input data + Returns: + 128 aligned data + """ + return align_up(value, 128) + +def align_up2(value): + """Align up data with 2 + Args: + value:input data + Returns: + 2 aligned data + """ + return align_up(value, 2) + +def yuv420sp_size(width, height): + """Calculate yuv420sp image size + Args: + width: image width + height: image height + Returns: + image data size + """ + return int(width * height * 3 / 2) + +def rgbu8_size(width, height): + """Calculate rgb 24bit image size + Args: + width: image width + height: image height + Returns: + rgb 24bit image data size + """ + return int(width * height * 3) + +def display_time(func): + """print func execute time""" + @wraps(func) + def wrapper(*args, **kwargs): + """wrapper caller""" + if DEBUG: + btime = time.time() + res = func(*args, **kwargs) + use_time = time.time() - btime + print("in %s, use time:%s" % (func.__name__, use_time)) + return res + else: + return func(*args, **kwargs) + return wrapper diff --git a/best_practices/contrib/ganomaly/acllite/cameracapture.py b/best_practices/contrib/ganomaly/acllite/cameracapture.py new file mode 100644 index 0000000000000000000000000000000000000000..e627bf20036bae33033a35a8a977d444ad595918 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/cameracapture.py @@ -0,0 +1,94 @@ +# !/usr/bin/env python +# -*- coding:utf-8 -*- +# +from ctypes import * +import os +import time +import sys +BASE_DIR = os.path.dirname(os.path.abspath(__file__)) +sys.path.append(BASE_DIR) + +from lib.acllite_so import libacllite +import constants as const +from acllite_image import AclLiteImage +from acllite_logger import log_error, log_info + +CAMERA_OK = 0 +CAMERA_ERROR = 1 + +CAMERA_CLOSED = 0 +CAMERA_OPENED = 1 + +class CameraOutputC(Structure): + """Ctypes parameter object for frame data""" + _fields_ = [ + ('size', c_int), + ('data', POINTER(c_ubyte)) + ] + +class CameraCapture(object): + """Atlas200dk board camera access class""" + def __init__(self, camera_id, fps=15, size=(1280, 720)): + """Create camera instance + Args: + camera_id: camera slot + fps: frame per second + size: frame resolution + """ + self._id = camera_id + self._fps = fps + self._width = size[0] + self._height = size[1] + self._size = int(self._width * self._height * 3 / 2) + self._status = CAMERA_CLOSED + if CAMERA_OK == self._open(): + self._status = CAMERA_OPENED + else: + log_error("Open camera %d failed" % (camera_id)) + + def _open(self): + ret = libacllite.OpenCameraEx(self._id, self._fps, + self._width, self._height) + if (ret != CAMERA_OK): + log_error("Open camera %d failed ,ret = %d" % (self._id, ret)) + return CAMERA_ERROR + self._status = CAMERA_OPENED + return CAMERA_OK + + def is_opened(self): + """Camera is opened or not""" + return (self._status == CAMERA_OPENED) + + def read(self): + """Read frame from camera""" + frame_data = CameraOutputC() + ret = libacllite.ReadCameraFrame(self._id, byref(frame_data)) + if (ret != CAMERA_OK): + log_error("Read camera %d failed" % (self._id)) + return None + + return AclLiteImage( + addressof(frame_data.data.contents), + self._width, + self._height, + 0, + 0, + self._size, + const.MEMORY_DVPP) + + def close(self): + """Close camera""" + log_info("Close camera ", self._id) + libacllite.CloseCameraEx(self._id) + + def __del__(self): + self.close() + +if __name__ == "__main__": + cap = Camera(camera_id=0, fps=15, size=(1280, 720)) + + start = time.time() + for i in range(0, 100): + image = cap.read() + print("Read 100 frame exhaust ", time.time() - start) + diff --git a/best_practices/contrib/ganomaly/acllite/constants.py b/best_practices/contrib/ganomaly/acllite/constants.py new file mode 100644 index 0000000000000000000000000000000000000000..8c2224980cd222383c7bd615403adfef33f22157 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/constants.py @@ -0,0 +1,217 @@ +""" +Copyright (R) @huawei.com, all rights reserved +-*- coding:utf-8 -*- +CREATED: 2020-6-04 20:12:13 +MODIFIED: 2020-6-06 14:04:45 +""" +SUCCESS = 0 +FAILED = 1 + +ACL_DEVICE = 0 +ACL_HOST = 1 + +MEMORY_NORMAL = 0 +MEMORY_HOST = 1 +MEMORY_DEVICE = 2 +MEMORY_DVPP = 3 +MEMORY_CTYPES = 4 + +IMAGE_DATA_NUMPY = 0 +IMAGE_DATA_BUFFER = 1 + +READ_VIDEO_OK = 0 + +# error code +ACL_SUCCESS = 0 +ACL_ERROR_INVALID_PARAM = 100000 +ACL_ERROR_UNINITIALIZE = 100001 +ACL_ERROR_REPEAT_INITIALIZE = 100002 +ACL_ERROR_INVALID_FILE = 100003 +ACL_ERROR_WRITE_FILE = 100004 +ACL_ERROR_INVALID_FILE_SIZE = 100005 +ACL_ERROR_PARSE_FILE = 100006 +ACL_ERROR_FILE_MISSING_ATTR = 100007 +ACL_ERROR_FILE_ATTR_INVALID = 100008 +ACL_ERROR_INVALID_DUMP_CONFIG = 100009 +ACL_ERROR_INVALID_PROFILING_CONFIG = 100010 +ACL_ERROR_INVALID_MODEL_ID = 100011 +ACL_ERROR_DESERIALIZE_MODEL = 100012 +ACL_ERROR_PARSE_MODEL = 100013 +ACL_ERROR_READ_MODEL_FAILURE = 100014 +ACL_ERROR_MODEL_SIZE_INVALID = 100015 +ACL_ERROR_MODEL_MISSING_ATTR = 100016 +ACL_ERROR_MODEL_INPUT_NOT_MATCH = 100017 +ACL_ERROR_MODEL_OUTPUT_NOT_MATCH = 100018 +ACL_ERROR_MODEL_NOT_DYNAMIC = 100019 +ACL_ERROR_OP_TYPE_NOT_MATCH = 100020 +ACL_ERROR_OP_INPUT_NOT_MATCH = 100021 +ACL_ERROR_OP_OUTPUT_NOT_MATCH = 100022 +ACL_ERROR_OP_ATTR_NOT_MATCH = 100023 +ACL_ERROR_OP_NOT_FOUND = 100024 +ACL_ERROR_OP_LOAD_FAILED = 100025 +ACL_ERROR_UNSUPPORTED_DATA_TYPE = 100026 +ACL_ERROR_FORMAT_NOT_MATCH = 100027 +ACL_ERROR_BIN_SELECTOR_NOT_REGISTERED = 100028 +ACL_ERROR_KERNEL_NOT_FOUND = 100029 +ACL_ERROR_BIN_SELECTOR_ALREADY_REGISTERED = 100030 +ACL_ERROR_KERNEL_ALREADY_REGISTERED = 100031 +ACL_ERROR_INVALID_QUEUE_ID = 100032 +ACL_ERROR_REPEAT_SUBSCRIBE = 100033 +ACL_ERROR_STREAM_NOT_SUBSCRIBE = 100034 +ACL_ERROR_THREAD_NOT_SUBSCRIBE = 100035 +ACL_ERROR_WAIT_CALLBACK_TIMEOUT = 100036 +ACL_ERROR_REPEAT_FINALIZE = 100037 +ACL_ERROR_BAD_ALLOC = 200000 +ACL_ERROR_API_NOT_SUPPORT = 200001 +ACL_ERROR_INVALID_DEVICE = 200002 +ACL_ERROR_MEMORY_ADDRESS_UNALIGNED = 200003 +ACL_ERROR_RESOURCE_NOT_MATCH = 200004 +ACL_ERROR_INVALID_RESOURCE_HANDLE = 200005 +ACL_ERROR_STORAGE_OVER_LIMIT = 300000 +ACL_ERROR_INTERNAL_ERROR = 500000 +ACL_ERROR_FAILURE = 500001 +ACL_ERROR_GE_FAILURE = 500002 +ACL_ERROR_RT_FAILURE = 500003 +ACL_ERROR_DRV_FAILURE = 500004 +# rule for mem +ACL_MEM_MALLOC_HUGE_FIRST = 0 +ACL_MEM_MALLOC_HUGE_ONLY = 1 +ACL_MEM_MALLOC_NORMAL_ONLY = 2 +# rule for memory copy +ACL_MEMCPY_HOST_TO_HOST = 0 +ACL_MEMCPY_HOST_TO_DEVICE = 1 +ACL_MEMCPY_DEVICE_TO_HOST = 2 +ACL_MEMCPY_DEVICE_TO_DEVICE = 3 +# input +LAST_ONE = -1 +LAST_TWO = -2 +type_dict = { + "bool": 0, + "int8": 1, + "int16": 2, + "int32": 4, + "int64": 8, + "uint8": 1, + "uint16": 2, + "uint32": 4, + "uint64": 8, + "float16": 2, + "float32": 4, + "float64": 8, + "float_": 8 +} +NPY_BOOL = 0 +NPY_BYTE = 1 +NPY_UBYTE = 2 +NPY_SHORT = 3 +NPY_USHORT = 4 +NPY_INT = 5 +NPY_UINT = 6 +NPY_LONG = 7 +NPY_ULONG = 8 +NPY_LONGLONG = 9 +NPY_ULONGLONG = 10 + +ACL_DT_UNDEFINED = -1 +ACL_FLOAT = 0 +ACL_FLOAT16 = 1 +ACL_INT8 = 2 +ACL_INT32 = 3 +ACL_UINT8 = 4 +ACL_INT16 = 6 +ACL_UINT16 = 7 +ACL_UINT32 = 8 +ACL_INT64 = 9 +ACL_UINT64 = 10 +ACL_DOUBLE = 11 +ACL_BOOL = 12 + +# data format +ACL_FORMAT_UNDEFINED = -1 +ACL_FORMAT_NCHW = 0 +ACL_FORMAT_NHWC = 1 +ACL_FORMAT_ND = 2 +ACL_FORMAT_NC1HWC0 = 3 +ACL_FORMAT_FRACTAL_Z = 4 +ACL_DT_UNDEFINED = -1 +ACL_FLOAT = 0 +ACL_FLOAT16 = 1 +ACL_INT8 = 2 +ACL_INT32 = 3 +ACL_UINT8 = 4 +ACL_INT16 = 6 +ACL_UINT16 = 7 +ACL_UINT32 = 8 +ACL_INT64 = 9 +ACL_UINT64 = 10 +ACL_DOUBLE = 11 +ACL_BOOL = 12 +acl_dtype = { + "dt_undefined": -1, + "float": 0, + "float16": 1, + "int8": 2, + "int32": 3, + "uint8": 4, + "int16": 6, + "uint16": 7, + "uint32": 8, + "int64": 9, + "double": 11, + "bool": 12 +} +ACL_CALLBACK_NO_BLOCK = 0 +ACL_CALLBACK_BLOCK = 1 +PIXEL_FORMAT_YUV_400 = 0 # 0, YUV400 8bit +PIXEL_FORMAT_YUV_SEMIPLANAR_420 = 1 # 1, YUV420SP NV12 8bit +PIXEL_FORMAT_YVU_SEMIPLANAR_420 = 2 # 2, YUV420SP NV21 8bit +PIXEL_FORMAT_YUV_SEMIPLANAR_422 = 3 # 3, YUV422SP NV12 8bit +PIXEL_FORMAT_YVU_SEMIPLANAR_422 = 4 # 4, YUV422SP NV21 8bit +PIXEL_FORMAT_YUV_SEMIPLANAR_444 = 5 # 5, YUV444SP NV12 8bit +PIXEL_FORMAT_YVU_SEMIPLANAR_444 = 6 # 6, YUV444SP NV21 8bit +PIXEL_FORMAT_YUYV_PACKED_422 = 7 # 7, YUV422P YUYV 8bit +PIXEL_FORMAT_UYVY_PACKED_422 = 8 # 8, YUV422P UYVY 8bit +PIXEL_FORMAT_YVYU_PACKED_422 = 9 # 9, YUV422P YVYU 8bit +PIXEL_FORMAT_VYUY_PACKED_422 = 10 # 10, YUV422P VYUY 8bit +PIXEL_FORMAT_YUV_PACKED_444 = 11 # 11, YUV444P 8bit +PIXEL_FORMAT_RGB_888 = 12 # 12, RGB888 +PIXEL_FORMAT_BGR_888 = 13 # 13, BGR888 +PIXEL_FORMAT_ARGB_8888 = 14 # 14, ARGB8888 +PIXEL_FORMAT_ABGR_8888 = 15 # 15, ABGR8888 +PIXEL_FORMAT_RGBA_8888 = 16 # 16, RGBA8888 +PIXEL_FORMAT_BGRA_8888 = 17 # 17, BGRA8888 +PIXEL_FORMAT_YUV_SEMI_PLANNER_420_10BIT = 18 # 18, YUV420SP 10bit +PIXEL_FORMAT_YVU_SEMI_PLANNER_420_10BIT = 19 # 19, YVU420sp 10bit +PIXEL_FORMAT_YVU_PLANAR_420 = 20 # 20, YUV420P 8bit +# images format +IMG_EXT = ['.jpg', '.JPG', '.png', '.PNG', '.bmp', '.BMP', '.jpeg', '.JPEG'] + +ENCODE_FORMAT_UNKNOW = 0 +ENCODE_FORMAT_JPEG = 1 +ENCODE_FORMAT_PNG = 2 +ENCODE_FORMAT_YUV420_SP = 3 + +""" +enType 0 +0 H265 main level +1 H264 baseline level +2 H264 main level +3 H264 high level +""" +ENTYPE_H265_MAIN = 0 +ENTYPE_H264_BASE = 1 +ENTYPE_H264_MAIN = 2 +ENTYPE_H264_HIGH = 3 + +# h264 stream codec id +AV_CODEC_ID_H264 = 27 +# h265 stream codec id +AV_CODEC_ID_HEVC = 173 +# h264 baseline level +FF_PROFILE_H264_BASELINE = 66 +# h264 main level profile +FF_PROFILE_H264_MAIN = 77 +# h264 high level profile +FF_PROFILE_H264_HIGH = 100 +# h265 main level profile +FF_PROFILE_HEVC_MAIN = 1 diff --git a/best_practices/contrib/ganomaly/acllite/dvpp_vdec.py b/best_practices/contrib/ganomaly/acllite/dvpp_vdec.py new file mode 100644 index 0000000000000000000000000000000000000000..7c0bdb7aa8d54fa9639ad5221413019cd7a01ffa --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/dvpp_vdec.py @@ -0,0 +1,256 @@ +import numpy as np +import acl +import queue + +import constants as const +import acllite_utils as utils +import acllite_logger as acl_log +from acllite_image import AclLiteImage + +READ_TIMEOUT = 5 +WAIT_INTERVAL = 0.1 + +class DvppVdec(object): + """Decode h264/h265 stream by dvpp vdec + Decode one frame of h264/h265 stream.The stream must be h264 main, baseline + or high level, annex-b format, or h265 main level.Output image is yuv420sp + Attributes: + _channel_id: dvpp vdec channel parameter, must global unique + _width: input frame width + _height:input frame height + _run_flag:deocde is running or not currently, callback thread daemon condition + _callbak_tid: decode callback thread id + _channel_desc: vdec channel desc handle + _ctx: current thread acl context + _entype: video stream encode type, dvpp vdec support: + const.ENTYPE_H265_MAIN = 0 H265 main level + const.ENTYPE_H264_BASE = 1 H264 baseline level + const.ENTYPE_H264_MAIN = 2 H264 main level + const.ENTYPE_H264_HIGH = 3 H264 high level + _format: output frame image format, use yuv420sp + _decod_complete_cnt: output decoded complete frames counter + _decode_cnt: input frames counter + _output_pic_size: output image data size + _frame_queue: output decoded frame image queue + """ + + def __init__(self, channel_id, width, height, entype, ctx, + output_format=const.PIXEL_FORMAT_YUV_SEMIPLANAR_420): + """Create dvpp vdec instance + Args: + channel_id: decode channel id, must be global unique + width: frame width + height: frame height + entype: video stream encode type + ctx: current thread acl context + output_format: output image format, support yuv420 nv12 and nv21 + """ + self._channel_id = channel_id + self._width = width + self._height = height + self._run_flag = True + self._callbak_tid = None + self._channel_desc = None + self._ctx = ctx + self._entype = entype + self._format = output_format + self._decode_complete_cnt = 0 + self._decode_cnt = 0 + self._output_pic_size = (self._width * self._height * 3) // 2 + self._frame_queue = queue.Queue(64) + self._frame_config = None + self._destory_channel_flag = False + + def _callback_thread_entry(self, args_list): + ret = acl.rt.set_context(self._ctx) + while self._run_flag is True: + ret = acl.rt.process_report(300) + + def _callback(self, input_stream_desc, output_pic_desc, user_data): + self._decode_complete_cnt += 1 + #print("callback ", self._decode_complete_cnt) + input_stream_data = acl.media.dvpp_get_stream_desc_data( + input_stream_desc) + input_stream_data_size = acl.media.dvpp_get_stream_desc_size( + input_stream_desc) + ret = acl.media.dvpp_destroy_stream_desc(input_stream_desc) + + self._get_pic_desc_data(output_pic_desc, user_data) + + def _get_pic_desc_data(self, pic_desc, user_data): + pic_data = acl.media.dvpp_get_pic_desc_data(pic_desc) + pic_data_size = acl.media.dvpp_get_pic_desc_size(pic_desc) + ret_code = acl.media.dvpp_get_pic_desc_ret_code(pic_desc) + if ret_code: + channel_id, frame_id = user_data + acl_log.log_error("Decode channel %d frame %d failed, error %d" + % (channel_id, frame_id, ret_code)) + acl.media.dvpp_free(pic_data) + else: + image = AclLiteImage(pic_data, self._width, self._height, 0, 0, + pic_data_size, const.MEMORY_DVPP) + self._frame_queue.put(image) + acl.media.dvpp_destroy_pic_desc(pic_desc) + + def init(self): + """Init dvpp vdec + Returns: + const.SUCCESS: init success + const.FAILED: init failed + """ + # print("0") + self._channel_desc = acl.media.vdec_create_channel_desc() + self._callbak_tid, ret = acl.util.start_thread( + self._callback_thread_entry, []) + acl.media.vdec_set_channel_desc_channel_id(self._channel_desc, + self._channel_id) + acl.media.vdec_set_channel_desc_thread_id(self._channel_desc, + self._callbak_tid) + + # print("1") + acl.media.vdec_set_channel_desc_callback(self._channel_desc, + self._callback) + + acl.media.vdec_set_channel_desc_entype(self._channel_desc, + self._entype) + acl.media.vdec_set_channel_desc_out_pic_format(self._channel_desc, + self._format) + # print("3") + out_mode = acl.media.vdec_get_channel_desc_out_mode(self._channel_desc) + if out_mode != 0: + acl_log.log_error("Dvpp vdec out mode(%d) is invalid" % (out_mode)) + return const.FAILED + + acl.media.vdec_set_channel_desc_out_mode(self._channel_desc, + out_mode) + acl.media.vdec_create_channel(self._channel_desc) + + self._frame_config = acl.media.vdec_create_frame_config() + if self._frame_config is None: + acl_log.log_error("Create dvpp frame config failed") + return const.FAILED + + return const.SUCCESS + + def _thread_join(self): + if self._callbak_tid is not None: + self._run_flag = False + ret = acl.util.stop_thread(self._callbak_tid) + self._callbak_tid = None + + def process(self, input_data, input_size, user_data): + """Decode frame + Args: + input_data: input frame data + input_size: input frame data size + + Returns: + const.SUCCESS: process success + const.FAILED: process failed + """ + input_stream_desc = self._create_input_pic_stream_desc(input_data, + input_size) + if input_stream_desc is None: + acl_log.log_error("Dvpp vdec decode frame failed for " + "create input stream desc error") + return const.FAILED + + output_pic_desc = self._create_output_pic_desc() + if output_pic_desc is None: + acl_log.log_error("Dvpp vdec decode frame failed for create " + "output pic desc failed") + return const.FAILED + + ret = acl.media.vdec_send_frame(self._channel_desc, input_stream_desc, + output_pic_desc, self._frame_config, + user_data) + if ret: + acl_log.log_error("Dvpp vdec send frame failed, error ", ret) + return const.FAILED + + self._decode_cnt += 1 + #print("send frame ", self._decode_cnt) + + return const.SUCCESS + + def _create_input_pic_stream_desc(self, input_data, input_size): + stream_desc = acl.media.dvpp_create_stream_desc() + if stream_desc is None: + acl_log.log_error("Create dvpp vdec input pic stream desc failed") + return None + + acl.media.dvpp_set_stream_desc_size(stream_desc, input_size) + acl.media.dvpp_set_stream_desc_data(stream_desc, input_data) + + return stream_desc + + def _create_output_pic_desc(self): + output_buffer, ret = acl.media.dvpp_malloc(self._output_pic_size) + if (output_buffer is None) or ret: + acl_log.log_error( + "Dvpp vdec malloc output memory failed, " + "size %d, error %d" % + (self._output_pic_size, ret)) + return None + + pic_desc = acl.media.dvpp_create_pic_desc() + if pic_desc is None: + acl_log.log_error("Create dvpp vdec output pic desc failed") + return None + + acl.media.dvpp_set_pic_desc_data(pic_desc, output_buffer) + acl.media.dvpp_set_pic_desc_size(pic_desc, self._output_pic_size) + acl.media.dvpp_set_pic_desc_format(pic_desc, self._format) + + return pic_desc + + def destroy(self): + """Release dvpp vdec resource""" + #print("vdec destroy****************") + if self._channel_desc is not None: + ret = acl.media.vdec_destroy_channel(self._channel_desc) + self._channel_desc = None + + self._thread_join() + + if self._frame_config is not None: + acl.media.vdec_destroy_frame_config(self._frame_config) + self._frame_config = None + self._destory_channel_flag = True + + def is_finished(self): + """Video decode finished""" + return ((self._decode_cnt > 0) and + (self._decode_complete_cnt >= self._decode_cnt)) + + def read(self, no_wait=False): + """Read decoded frame + no_wait: Get image without wait. If set this arg True, and + return image is None, should call is_finished() method + to confirm decode finish or failed + + Returns: + 1. const.SUCCESS, not None: get image success + 2. const.SUCCESS, None: all frames decoded and be token off + 3. const.FAILED, None: Has frame not decoded, but no image decoded, + it means decode video failed + """ + image = None + ret = const.SUCCESS + # received eos frame and all received frame decode complete + if no_wait or self.is_finished(): + try: + image = self._frame_queue.get_nowait() + except queue.Empty: + acl_log.log_info("No decode frame in queue anymore") + else: + try: + image = self._frame_queue.get(timeout=READ_TIMEOUT) + except queue.Empty: + ret = const.FAILED + acl_log.log_error("Read channel id %d frame timeout, " + "receive frame %d, decoded %d" + % (self._channel_id, self._decode_cnt, + self._decode_complete_cnt)) + return ret, image + diff --git a/best_practices/contrib/ganomaly/acllite/lib/__init__.py b/best_practices/contrib/ganomaly/acllite/lib/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/best_practices/contrib/ganomaly/acllite/lib/acllite_so.py b/best_practices/contrib/ganomaly/acllite/lib/acllite_so.py new file mode 100644 index 0000000000000000000000000000000000000000..c2fde939879630c922636c756bd5674b46b456ca --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/lib/acllite_so.py @@ -0,0 +1,38 @@ +import threading +import ctypes +import os +import platform + +import acl + +from constants import ACL_HOST, ACL_DEVICE + + +def _load_lib_acllite(): + run_mode, ret = acl.rt.get_run_mode() + + lib = None + if run_mode == ACL_DEVICE: + cur_dir = os.path.dirname(os.path.abspath(__file__)) + so_path = os.path.join(cur_dir, 'atlas200dk/libpython_acllite.so') + lib=ctypes.CDLL(so_path) + + return lib + + +class _AclLiteLib(object): + _instance_lock=threading.Lock() + lib=_load_lib_acllite() + + def __init__(self): + pass + + def __new__(cls, *args, **kwargs): + if not hasattr(_AclLiteLib, "_instance"): + with _AclLiteLib._instance_lock: + if not hasattr(_AclLiteLib, "_instance"): + _AclLiteLib._instance=object.__new__( + cls, *args, **kwargs) + return _AclLiteLib._instance + +libacllite=_AclLiteLib.lib diff --git a/best_practices/contrib/ganomaly/acllite/lib/atlas200dk/libpython_acllite.so b/best_practices/contrib/ganomaly/acllite/lib/atlas200dk/libpython_acllite.so new file mode 100644 index 0000000000000000000000000000000000000000..85971c9938adc748ff12b66dd24581b646f5a7bc Binary files /dev/null and b/best_practices/contrib/ganomaly/acllite/lib/atlas200dk/libpython_acllite.so differ diff --git a/best_practices/contrib/ganomaly/acllite/lib/src/Makefile b/best_practices/contrib/ganomaly/acllite/lib/src/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..9ba097a6e38835fd625389fcfb42371f2df23b40 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/lib/src/Makefile @@ -0,0 +1,88 @@ +TOPDIR := $(patsubst %,%,$(CURDIR)) + +ifndef CPU_ARCH +$(error "Can not find CPU_ARCH env, please set it in environment!.") +endif + +ifndef INSTALL_DIR +$(error "Can not find INSTALL_DIR env, please set it in environment!.") +endif + +ifndef THIRDPART_PATH +$(error "Can not find THIRDPART_PATH env, please set it in environment!.") +endif + +media_mini_exist = $(shell if [ -f ${INSTALL_DIR}/driver/libmedia_mini.so ]; then echo "exist"; else echo "notexist"; fi;) + +ifeq ($(CPU_ARCH), aarch64) + CC := aarch64-linux-gnu-g++ + OUT_DIR = ../atlas200dk +else ifeq ($(CPU_ARCH), x86_64) + CC := g++ +else + $(error "Unsupported param: "$(CPU_ARCH)) +endif + +LOCAL_MODULE_NAME := libpython_acllite.so + +LOCAL_DIR := . +OBJ_DIR = $(OUT_DIR)/obj +DEPS_DIR = $(OUT_DIR)/deps +LOCAL_LIBRARY=$(OUT_DIR)/$(LOCAL_MODULE_NAME) +OUT_INC_DIR = $(OUT_DIR)/include + +INC_DIR = \ + -I./ \ + -I../include \ + -I$(INSTALL_DIR)/driver/ \ + -I$(INSTALL_DIR)/runtime/include/ \ + -I$(THIRDPART_PATH)/include/ \ + -I$(THIRDPART_PATH)/include/presenter/agent/ \ + #-I$(DDK_PATH)/compiler/include/protobuf + +CC_FLAGS := $(INC_DIR) -DENABLE_DVPP_INTERFACE -std=c++11 -fPIC -Wall -O2 +LNK_FLAGS := \ + -Wl,-rpath-link=$(INSTALL_DIR)/runtime/lib64/stub \ + -Wl,-rpath-link=$(THIRDPART_PATH)/lib \ + -L$(INSTALL_DIR)/runtime/lib64/stub \ + -L$(THIRDPART_PATH)/lib \ + -lascendcl \ + -lacl_dvpp \ + -lstdc++ \ + -lpthread \ + -shared + +ifeq ($(media_mini_exist),exist) +LNK_FLAGS += -L${INSTALL_DIR}/driver -lmedia_mini +endif + +SRCS_ALL := $(patsubst $(LOCAL_DIR)/%.cpp, %.cpp, $(shell find $(LOCAL_DIR) -name "*.cpp")) +ifeq ($(media_mini_exist),exist) +SRCS := $(SRCS_ALL) +else +SRCS := $(subst camera.cpp, ,$(SRCS_ALL)) +endif + +OBJS := $(addprefix $(OBJ_DIR)/, $(patsubst %.cpp, %.o,$(SRCS))) +ALL_OBJS := $(OBJS) + +all: do_pre_build do_build + +do_pre_build: + $(Q)echo - do [$@] + $(Q)mkdir -p $(OBJ_DIR) + +do_build: $(LOCAL_LIBRARY) | do_pre_build + $(Q)echo - do [$@] + +$(LOCAL_LIBRARY): $(ALL_OBJS) + $(Q)echo [LD] $@ + $(Q)$(CC) $(CC_FLAGS) -o $@ $^ -Wl,--whole-archive -Wl,--no-whole-archive -Wl,--start-group -Wl,--end-group -Wl,-rpath='/home/HwHiAiUser/HIAI_PROJECTS/ascend_lib' $(LNK_FLAGS) + +$(OBJS): $(OBJ_DIR)/%.o : %.cpp | do_pre_build + $(Q)echo [CC] $@ + $(Q)mkdir -p $(dir $@) + $(Q)$(CC) $(CC_FLAGS) $(INC_DIR) -c -fstack-protector-all $< -o $@ + +clean: + rm -rf $(OUT_DIR)/* diff --git a/best_practices/contrib/ganomaly/acllite/lib/src/acllite_utils.h b/best_practices/contrib/ganomaly/acllite/lib/src/acllite_utils.h new file mode 100644 index 0000000000000000000000000000000000000000..0e5851b9e98379aa77241f65c62bebbaaaad1b8b --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/lib/src/acllite_utils.h @@ -0,0 +1,67 @@ +/** +* Copyright 2020 Huawei Technologies Co., Ltd +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at + +* http://www.apache.org/licenses/LICENSE-2.0 + +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. + +* File utils.h +* Description: handle file operations +*/ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include "acl/acl.h" + +extern "C" { + +/** + * @brief calculate YUVSP420 image size + * @param [in] width: image width + * @param [in] height: image height + * @return bytes size of image + */ +#define YUV420SP_SIZE(width, height) ((width) * (height) * 3 / 2) + +/** + * @brief Write acl error level log to host log + * @param [in] fmt: the input format string + * @return none + */ +#define ACLLITE_LOG_ERROR(fmt, ...) \ + do{aclAppLog(ACL_ERROR, __FUNCTION__, __FILE__, __LINE__, fmt, ##__VA_ARGS__); \ + fprintf(stdout, "[ERROR] " fmt "\n", ##__VA_ARGS__);}while(0) + +/** + * @brief Write acl info level log to host log + * @param [in] fmt: the input format string + * @return none + */ +#define ACLLITE_LOG_INFO(fmt, ...) \ + do{aclAppLog(ACL_INFO, __FUNCTION__, __FILE__, __LINE__, fmt, ##__VA_ARGS__); \ + fprintf(stdout, "[INFO] " fmt "\n", ##__VA_ARGS__);}while(0) + +/** + * @brief Write acl debug level log to host log + * @param [in] fmt: the input format string + * @return none + */ +#define ACLLITE_LOG_DEBUG(fmt, ...) \ + do{aclAppLog(ACL_DEBUG, __FUNCTION__, __FILE__, __LINE__, fmt, ##__VA_ARGS__); \ + fprintf(stdout, "[INFO] " fmt "\n", ##__VA_ARGS__);}while(0) +} \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/acllite/lib/src/camera.cpp b/best_practices/contrib/ganomaly/acllite/lib/src/camera.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d2809078cc3b473459a00b1d8025baa53d87d1f0 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/lib/src/camera.cpp @@ -0,0 +1,167 @@ +/** + * ============================================================================ + * + * Copyright (C) 2018, Hisilicon Technologies Co., Ltd. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1 Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2 Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3 Neither the names of the copyright holders nor the names of the + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * ============================================================================ + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include "acl/acl.h" +#include "acl/ops/acl_dvpp.h" +#include "acllite_utils.h" +#include "camera.h" + +using namespace std; + +extern "C" { +#include "peripheral_api.h" +#include "camera.h" +CameraManager g_CameraMgr; + +void HwInit() { + if (!g_CameraMgr.hwInited) { + MediaLibInit(); + g_CameraMgr.hwInited = 1; + } +} + +int CameraInit(int id, int fps, int width, int height) { + Camera& cap = CAMERA(id); + cap.frameSize = YUV420SP_SIZE(width, height); + cap.id = id; + cap.fps = fps; + cap.width = width; + cap.height = height; + cap.inited = true; + + return ACLLITE_OK; +} + +int ConfigCamera(int id, int fps, int width, int height) { + int ret = SetCameraProperty(id, CAMERA_PROP_FPS, &fps); + if (ret == LIBMEDIA_STATUS_FAILED) { + ACLLITE_LOG_ERROR("Set camera fps failed"); + return ACLLITE_ERROR; + } + + CameraResolution resolution; + resolution.width = width; + resolution.height = height; + ret = SetCameraProperty(id, CAMERA_PROP_RESOLUTION, &resolution); + if (ret == LIBMEDIA_STATUS_FAILED) { + ACLLITE_LOG_ERROR("Set camera resolution failed"); + return ACLLITE_ERROR; + } + + CameraCapMode mode = CAMERA_CAP_ACTIVE; + ret = SetCameraProperty(id, CAMERA_PROP_CAP_MODE, &mode); + if (ret == LIBMEDIA_STATUS_FAILED) { + ACLLITE_LOG_ERROR("Set camera mode:%d failed", mode); + return ACLLITE_ERROR; + } + + return ACLLITE_OK; +} + +int OpenCameraEx(int id, int fps, int width, int height) { + if ((id < 0) || (id >= CAMERA_NUM)) { + ACLLITE_LOG_ERROR("Open camera failed for invalid id %d", id); + return ACLLITE_ERROR; + } + + HwInit(); + + CameraStatus status = QueryCameraStatus(id); + if (status == CAMERA_STATUS_CLOSED){ + // Open Camera + if (LIBMEDIA_STATUS_FAILED == OpenCamera(id)) { + ACLLITE_LOG_ERROR("Camera%d closed, and open failed.", id); + return ACLLITE_ERROR; + } + } else if (status != CAMERA_STATUS_OPEN) { + //如果摄像头状态不是close状态也不是open状态,则认为摄像头异常 + ACLLITE_LOG_ERROR("Invalid camera%d status %d", id, status); + return ACLLITE_ERROR; + } + + //Set camera property + if (ACLLITE_OK != ConfigCamera(id, fps, width, height)) { + CloseCamera(id); + ACLLITE_LOG_ERROR("Set camera%d property failed", id); + return ACLLITE_ERROR; + } + + if (!CAMERA(id).inited) { + CameraInit(id, fps, width, height); + } + + ACLLITE_LOG_INFO("Open camera %d success", id); + + return ACLLITE_OK; +} + +int ReadCameraFrame(int id, CameraOutput& frame) { + int size = CAMERA(id).frameSize; + void* data = nullptr; + auto aclRet = acldvppMalloc(&data, size); + if (aclRet != ACL_SUCCESS) { + ACLLITE_LOG_ERROR("acl malloc dvpp data failed, dataSize %d, error %d", + size, aclRet); + return ACLLITE_ERROR; + } + + int ret = ReadFrameFromCamera(id, (void*)data, (int *)&size); + if ((ret == LIBMEDIA_STATUS_FAILED) || + (size != CAMERA(id).frameSize)) { + acldvppFree(data); + ACLLITE_LOG_ERROR("Get image from camera %d failed, size %d", id, size); + return ACLLITE_ERROR; + } + frame.size = size; + frame.data = (uint8_t*)data; + + return ACLLITE_OK; +} + +int CloseCameraEx(int cameraId) { + if (LIBMEDIA_STATUS_FAILED == CloseCamera(cameraId)) { + ACLLITE_LOG_ERROR("Close camera %d failed", cameraId); + return ACLLITE_ERROR; + } + + return ACLLITE_OK; +} + +} diff --git a/best_practices/contrib/ganomaly/acllite/lib/src/camera.h b/best_practices/contrib/ganomaly/acllite/lib/src/camera.h new file mode 100644 index 0000000000000000000000000000000000000000..ca40d61c117cec1b083bb27c46f9f3ae72fe29c5 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/lib/src/camera.h @@ -0,0 +1,61 @@ +/** + * ============================================================================ + * + * Copyright (C) 2018, Hisilicon Technologies Co., Ltd. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1 Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2 Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * 3 Neither the names of the copyright holders nor the names of the + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * ============================================================================ + */ +#ifndef _CAMERA_H +#define _CAMERA_H + +#define CAMERA_NUM (2) +#define CAMERA(i) (g_CameraMgr.cap[i]) + +const int ACLLITE_OK = 0; +const int ACLLITE_ERROR = 1; + +struct CameraOutput { + int size; + uint8_t* data; +}; + +struct Camera { + bool inited = false; + int id = 255; + int fps = 0; + int width = 0; + int height = 0; + int frameSize = 0; +}; + +struct CameraManager { + bool hwInited = 0; + Camera cap[CAMERA_NUM]; +}; + +#endif diff --git a/best_practices/contrib/ganomaly/acllite/presenteragent/__init__.py b/best_practices/contrib/ganomaly/acllite/presenteragent/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/presenteragent/__init__.py @@ -0,0 +1 @@ + diff --git a/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_agent.py b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_agent.py new file mode 100644 index 0000000000000000000000000000000000000000..a69c1a8eed622b0d08173aa5ce1419e82a4e028b --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_agent.py @@ -0,0 +1,91 @@ +# !/usr/bin/env python +# -*- coding:utf-8 -*- +import time +from threading import Thread +import sys + +from acllite_logger import log_error, log_info +from presenteragent.socket_client import AgentSocket +import presenteragent.presenter_message as pm +import presenteragent.presenter_datatype as datatype + + +class PresenterAgent(object): + """Message proxy to presenter server""" + def __init__(self, server_ip, port): + self.socket = AgentSocket(server_ip, port) + self._closed = False + self.heart_beat_thread = None + + def connect_server(self): + """Connect presenter server""" + return self.socket.connect() + + def start_heard_beat_thread(self): + """Start thread that send heardbeat messages""" + self.heart_beat_thread = Thread(target=self._keep_alive) + self.heart_beat_thread.start() + + def _keep_alive(self): + msg = pm.heartbeat_message() + + while True: + if self._closed: + log_error("Heard beat thread exit") + break + + self.socket.send_msg(msg) + time.sleep(2) + + def exit(self): + """Proxy exit""" + self.socket.close() + self._closed = True + + +def StartPresenterAgent( + msg_queue, + server_ip, + port, + open_status, + data_respone_counter): + """Startup presenter agent""" + agent = PresenterAgent(server_ip, port) + ret = agent.connect_server() + if ret: + log_error("Connect server failed, ret =", ret) + return + + open_status.value = datatype.STATUS_CONNECTED + + while True: + data = msg_queue.get() + if data is None: + continue + + if isinstance(data, datatype.FinishMsg): + log_info("Receive presenter agent exit notification, queue size ", + msg_queue.qsize()) + time.sleep(0.1) + agent.exit() + break + + agent.socket.send_msg(data) + msg_name, msg_body = agent.socket.recv_msg() + if (msg_name is None) or (msg_body is None): + log_error("Recv invalid message, message name ", msg_name) + continue + + if ((open_status.value == datatype.STATUS_CONNECTED) and + pm.is_open_channel_response(msg_name)): + log_info("Received open channel respone") + open_status.value = datatype.STATUS_OPENED + agent.start_heard_beat_thread() + log_info( + "presenter agent change connect_status to ", + open_status.value) + + if ((open_status.value == datatype.STATUS_OPENED) and + pm.is_image_frame_response(msg_name)): + data_respone_counter.value += 1 + #log_info("send ok ", data_respone_counter.value) diff --git a/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_channel.py b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_channel.py new file mode 100644 index 0000000000000000000000000000000000000000..c5557eadbc714cd29d302fe26d52933cbae293c2 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_channel.py @@ -0,0 +1,144 @@ +# !/usr/bin/env python +# -*- coding:utf-8 -*- +import time +import configparser +from multiprocessing import Process, Queue, Manager +import queue +import numpy as np +import sys +# sys.path.append("..") + +import acl +import constants as const +from acllite_logger import log_error, log_info +from acllite_image import AclLiteImage + + +import presenteragent.presenter_datatype as dtype +import presenteragent.presenter_agent as agent +import presenteragent.presenter_message as pm + + +class PresenterChannel(object): + """Communication channel between presenter agent and server""" + def __init__(self, server_ip, port, name='video', + content_type=dtype.CONTENT_TYPE_VIDEO): + """Create instance""" + self._server_ip = server_ip + self._port = port + self._type = content_type + self._name = name + self.agent_msg_queue = Queue() + self.open_status = Manager().Value('i', dtype.STATUS_DISCONNECT) + self.data_respone_counter = Manager().Value('i', 0) + self._send_counter = 0 + + def startup(self): + """Create channel and connect with presenter server + Returns: + 0 connect success + 1 connect failed + """ + agent_process = Process( + target=agent.StartPresenterAgent, + args=( + self.agent_msg_queue, + self._server_ip, + self._port, + self.open_status, + self.data_respone_counter)) + agent_process.start() + time.sleep(0.5) + self._send_open_channel_request(self._name, self._type) + return self._wait_open_status(dtype.STATUS_OPENED) + + def _wait_open_status(self, listen_status): + ret = dtype.STATUS_ERROR + for i in range(0, 100): + time.sleep(0.001) + if self.open_status.value == listen_status: + log_info("Open status is %d now" % (listen_status)) + ret = dtype.STATUS_OK + break + return ret + + def send_message(self, data): + """Send message to presenter server""" + self.agent_msg_queue.put(data) + self._send_counter += 1 + + def _send_open_channel_request(self, channel_name, content_type): + request_msg = pm.open_channel_request(channel_name, content_type) + self.send_message(request_msg) + + def send_detection_data(self, image_width, image_height, + image, detection_result): + """Send image frame request to presenter server""" + image_data = None + if isinstance(image, AclLiteImage): + image_data = image.byte_data_to_np_array() + elif isinstance(image, np.ndarray): + image_data = image + else: + log_error("Invalid data to send, ", image) + return False + + request_msg = pm.image_frame_request(image_width, image_height, + image_data.tobytes(), + detection_result) + self.send_message(request_msg) + + return True + + def send_image(self, image_width, image_height, image): + """Send image frame request that only has image to presenter server""" + detection_result = [] + return self.send_detection_data(image_width, image_height, + image, detection_result) + + def _send_heart_beat_message(self): + msg = pm.heartbeat_message() + self.send_message(msg) + + def close(self): + """Close channel""" + if self.open_status == dtype.STATUS_EXITTED: + return + + log_info("Presenter channel close...") + eos = dtype.FinishMsg("exit") + self.send_message(eos) + while self.agent_msg_queue.qsize() > 0: + time.sleep(0.001) + self.open_status = dtype.STATUS_EXITTED + + def __del__(self): + self.close() + + +def get_channel_config(config_file): + """Get connect parameters from config file""" + config = configparser.ConfigParser() + config.read(config_file) + presenter_server_ip = config['baseconf']['presenter_server_ip'] + port = int(config['baseconf']['presenter_server_port']) + channel_name = config['baseconf']['channel_name'] + content_type = int(config['baseconf']['content_type']) + + log_info( + "presenter server ip %s, port %d, channel name %s, " + "type %d" % + (presenter_server_ip, port, channel_name, content_type)) + return presenter_server_ip, port, channel_name, content_type + + +def open_channel(config_file): + """Connect with presenter server""" + server_ip, port, channel_name, content_type = get_channel_config( + config_file) + channel = PresenterChannel(server_ip, port, channel_name, content_type) + ret = channel.startup() + if ret: + log_error("ERROR:Open channel failed") + return None + return channel diff --git a/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_datatype.py b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_datatype.py new file mode 100644 index 0000000000000000000000000000000000000000..b19415a0361bae61b5df149c5dafa10d2dc29eaa --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_datatype.py @@ -0,0 +1,70 @@ +STATUS_DISCONNECT = 0 +STATUS_CONNECTED = 1 +STATUS_OPEN_CH_REQUEST = 2 +STATUS_OPENED = 3 +STATUS_EXITING = 4 +STATUS_EXITTED = 5 + +CONTENT_TYPE_IMAGE = 0 +CONTENT_TYPE_VIDEO = 1 + +STATUS_OK = 0 +STATUS_ERROR = 1 + + +class Point(object): + """ + point coordinate + """ + + def __init__(self, x=0, y=0): + self.x = x + self.y = y + + +class Box(object): + """ + object rectangle area + """ + + def __init__(self, lt, rb): + self.lt = Point(lt) + self.rb = Point(rb) + + def box_valid(self): + """ + verify box coordinate is valid + """ + return ((self.lt.x >= 0) + and (self.lt.y >= 0) + and (self.rb.x >= self.lt.x) + and (self.rb.y >= self.lt.y)) + + +class ObjectDetectionResult(object): + """ + object detection information, include object position, confidence and label + """ + + def __init__(self, ltx=0, lty=0, rbx=0, rby=0, text=None): + self.object_class = 0 + self.confidence = 0 + self.box = Box((ltx, lty), (rbx, rby)) + self.result_text = text + + def check_box_vaild(self, width, height): + """ + verify object position is valid + """ + return (self.box.box_valid() and + (self.box.rb.x <= width) and + (self.box.rb.y <= height)) + + +class FinishMsg(object): + """ + the message to notify presenter agent exit + """ + + def __init__(self, data): + self.data = data diff --git a/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_message.proto b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_message.proto new file mode 100644 index 0000000000000000000000000000000000000000..879d5572b3cd434dc41dd18ecbd3e2f16ed3f42c --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_message.proto @@ -0,0 +1,67 @@ +syntax = "proto3"; + +package ascend.presenter.proto; + +enum OpenChannelErrorCode { + kOpenChannelErrorNone = 0; + kOpenChannelErrorNoSuchChannel = 1; + kOpenChannelErrorChannelAlreadyOpened = 2; + kOpenChannelErrorOther = -1; +} + +enum ChannelContentType { + kChannelContentTypeImage = 0; + kChannelContentTypeVideo = 1; +} + +// By Protocol Buffer Style Guide, need to use underscore_separated_names +// for field names +message OpenChannelRequest { + string channel_name = 1; + ChannelContentType content_type = 2; +} + +message OpenChannelResponse { + OpenChannelErrorCode error_code = 1; + string error_message = 2; +} + +message HeartbeatMessage { + +} + +enum ImageFormat { + kImageFormatJpeg = 0; +} + +message Coordinate { + uint32 x = 1; + uint32 y = 2; +} + +message Rectangle_Attr { + Coordinate left_top = 1; + Coordinate right_bottom = 2; + string label_text = 3; +} + +message PresentImageRequest { + ImageFormat format = 1; + uint32 width = 2; + uint32 height = 3; + bytes data = 4; + repeated Rectangle_Attr rectangle_list = 5; +} + +enum PresentDataErrorCode { + kPresentDataErrorNone = 0; + kPresentDataErrorUnsupportedType = 1; + kPresentDataErrorUnsupportedFormat = 2; + kPresentDataErrorOther = -1; +} + +message PresentImageResponse { + PresentDataErrorCode error_code = 1; + string error_message = 2; +} + diff --git a/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_message.py b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_message.py new file mode 100644 index 0000000000000000000000000000000000000000..383eff6937fecfad3c0d936c756e6cef36eebaaa --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_message.py @@ -0,0 +1,70 @@ +# !/usr/bin/env python +# -*- coding:utf-8 -*- +import struct +import socket + +import presenteragent.presenter_message_pb2 as pb2 + + +def pack_message(msg_name, msg_data): + """Pack message name and data to byte stream""" + buf = msg_data.SerializeToString() + msg_body_len = len(buf) + msg_name_len = len(msg_name) + msg_total_len = msg_name_len + msg_body_len + 5 + data = b'' + msg_total_len = socket.htonl(msg_total_len) + pack_data = struct.pack('IB', msg_total_len, msg_name_len) + data += pack_data + data += msg_name.encode() + data += buf + + return data + + +def open_channel_request(channel_name, content_type): + """Create open channel request message""" + request = pb2.OpenChannelRequest() + request.channel_name = channel_name + request.content_type = content_type + + return pack_message(pb2._OPENCHANNELREQUEST.full_name, request) + + +def image_frame_request( + image_width, + image_height, + image_data, + detection_result): + """Create image frame request message""" + request = pb2.PresentImageRequest() + request.format = 0 + request.width = image_width + request.height = image_height + request.data = image_data + for i in range(0, len(detection_result)): + myadd = request.rectangle_list.add() + myadd.left_top.x = detection_result[i].box.lt.x + myadd.left_top.y = detection_result[i].box.lt.y + myadd.right_bottom.x = detection_result[i].box.rb.x + myadd.right_bottom.y = detection_result[i].box.rb.y + myadd.label_text = detection_result[i].result_text + + return pack_message(pb2._PRESENTIMAGEREQUEST.full_name, request) + + +def heartbeat_message(): + """Create headbeat message""" + return pack_message( + pb2._HEARTBEATMESSAGE.full_name, + pb2.HeartbeatMessage()) + + +def is_open_channel_response(msg_name): + """Confirm the message is open channel response or not""" + return (msg_name == pb2._OPENCHANNELRESPONSE.full_name) + + +def is_image_frame_response(msg_name): + """Confirm the message is image frame response or not""" + return (msg_name == pb2._PRESENTIMAGERESPONSE.full_name) diff --git a/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_message_pb2.py b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_message_pb2.py new file mode 100644 index 0000000000000000000000000000000000000000..6c99f06e821a0301d04206f15471bc8c771c6010 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/presenteragent/presenter_message_pb2.py @@ -0,0 +1,493 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: presenter_message.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='presenter_message.proto', + package='ascend.presenter.proto', + syntax='proto3', + serialized_pb=_b('\n\x17presenter_message.proto\x12\x16\x61scend.presenter.proto\"l\n\x12OpenChannelRequest\x12\x14\n\x0c\x63hannel_name\x18\x01 \x01(\t\x12@\n\x0c\x63ontent_type\x18\x02 \x01(\x0e\x32*.ascend.presenter.proto.ChannelContentType\"n\n\x13OpenChannelResponse\x12@\n\nerror_code\x18\x01 \x01(\x0e\x32,.ascend.presenter.proto.OpenChannelErrorCode\x12\x15\n\rerror_message\x18\x02 \x01(\t\"\x12\n\x10HeartbeatMessage\"\"\n\nCoordinate\x12\t\n\x01x\x18\x01 \x01(\r\x12\t\n\x01y\x18\x02 \x01(\r\"\x94\x01\n\x0eRectangle_Attr\x12\x34\n\x08left_top\x18\x01 \x01(\x0b\x32\".ascend.presenter.proto.Coordinate\x12\x38\n\x0cright_bottom\x18\x02 \x01(\x0b\x32\".ascend.presenter.proto.Coordinate\x12\x12\n\nlabel_text\x18\x03 \x01(\t\"\xb7\x01\n\x13PresentImageRequest\x12\x33\n\x06\x66ormat\x18\x01 \x01(\x0e\x32#.ascend.presenter.proto.ImageFormat\x12\r\n\x05width\x18\x02 \x01(\r\x12\x0e\n\x06height\x18\x03 \x01(\r\x12\x0c\n\x04\x64\x61ta\x18\x04 \x01(\x0c\x12>\n\x0erectangle_list\x18\x05 \x03(\x0b\x32&.ascend.presenter.proto.Rectangle_Attr\"o\n\x14PresentImageResponse\x12@\n\nerror_code\x18\x01 \x01(\x0e\x32,.ascend.presenter.proto.PresentDataErrorCode\x12\x15\n\rerror_message\x18\x02 \x01(\t*\xa5\x01\n\x14OpenChannelErrorCode\x12\x19\n\x15kOpenChannelErrorNone\x10\x00\x12\"\n\x1ekOpenChannelErrorNoSuchChannel\x10\x01\x12)\n%kOpenChannelErrorChannelAlreadyOpened\x10\x02\x12#\n\x16kOpenChannelErrorOther\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01*P\n\x12\x43hannelContentType\x12\x1c\n\x18kChannelContentTypeImage\x10\x00\x12\x1c\n\x18kChannelContentTypeVideo\x10\x01*#\n\x0bImageFormat\x12\x14\n\x10kImageFormatJpeg\x10\x00*\xa4\x01\n\x14PresentDataErrorCode\x12\x19\n\x15kPresentDataErrorNone\x10\x00\x12$\n kPresentDataErrorUnsupportedType\x10\x01\x12&\n\"kPresentDataErrorUnsupportedFormat\x10\x02\x12#\n\x16kPresentDataErrorOther\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x62\x06proto3') +) + +_OPENCHANNELERRORCODE = _descriptor.EnumDescriptor( + name='OpenChannelErrorCode', + full_name='ascend.presenter.proto.OpenChannelErrorCode', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='kOpenChannelErrorNone', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='kOpenChannelErrorNoSuchChannel', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='kOpenChannelErrorChannelAlreadyOpened', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='kOpenChannelErrorOther', index=3, number=-1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=780, + serialized_end=945, +) +_sym_db.RegisterEnumDescriptor(_OPENCHANNELERRORCODE) + +OpenChannelErrorCode = enum_type_wrapper.EnumTypeWrapper(_OPENCHANNELERRORCODE) +_CHANNELCONTENTTYPE = _descriptor.EnumDescriptor( + name='ChannelContentType', + full_name='ascend.presenter.proto.ChannelContentType', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='kChannelContentTypeImage', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='kChannelContentTypeVideo', index=1, number=1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=947, + serialized_end=1027, +) +_sym_db.RegisterEnumDescriptor(_CHANNELCONTENTTYPE) + +ChannelContentType = enum_type_wrapper.EnumTypeWrapper(_CHANNELCONTENTTYPE) +_IMAGEFORMAT = _descriptor.EnumDescriptor( + name='ImageFormat', + full_name='ascend.presenter.proto.ImageFormat', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='kImageFormatJpeg', index=0, number=0, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=1029, + serialized_end=1064, +) +_sym_db.RegisterEnumDescriptor(_IMAGEFORMAT) + +ImageFormat = enum_type_wrapper.EnumTypeWrapper(_IMAGEFORMAT) +_PRESENTDATAERRORCODE = _descriptor.EnumDescriptor( + name='PresentDataErrorCode', + full_name='ascend.presenter.proto.PresentDataErrorCode', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='kPresentDataErrorNone', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='kPresentDataErrorUnsupportedType', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='kPresentDataErrorUnsupportedFormat', index=2, number=2, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='kPresentDataErrorOther', index=3, number=-1, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=1067, + serialized_end=1231, +) +_sym_db.RegisterEnumDescriptor(_PRESENTDATAERRORCODE) + +PresentDataErrorCode = enum_type_wrapper.EnumTypeWrapper(_PRESENTDATAERRORCODE) +kOpenChannelErrorNone = 0 +kOpenChannelErrorNoSuchChannel = 1 +kOpenChannelErrorChannelAlreadyOpened = 2 +kOpenChannelErrorOther = -1 +kChannelContentTypeImage = 0 +kChannelContentTypeVideo = 1 +kImageFormatJpeg = 0 +kPresentDataErrorNone = 0 +kPresentDataErrorUnsupportedType = 1 +kPresentDataErrorUnsupportedFormat = 2 +kPresentDataErrorOther = -1 + + + +_OPENCHANNELREQUEST = _descriptor.Descriptor( + name='OpenChannelRequest', + full_name='ascend.presenter.proto.OpenChannelRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='channel_name', full_name='ascend.presenter.proto.OpenChannelRequest.channel_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='content_type', full_name='ascend.presenter.proto.OpenChannelRequest.content_type', index=1, + number=2, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=51, + serialized_end=159, +) + + +_OPENCHANNELRESPONSE = _descriptor.Descriptor( + name='OpenChannelResponse', + full_name='ascend.presenter.proto.OpenChannelResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='error_code', full_name='ascend.presenter.proto.OpenChannelResponse.error_code', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='error_message', full_name='ascend.presenter.proto.OpenChannelResponse.error_message', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=161, + serialized_end=271, +) + + +_HEARTBEATMESSAGE = _descriptor.Descriptor( + name='HeartbeatMessage', + full_name='ascend.presenter.proto.HeartbeatMessage', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=273, + serialized_end=291, +) + + +_COORDINATE = _descriptor.Descriptor( + name='Coordinate', + full_name='ascend.presenter.proto.Coordinate', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='x', full_name='ascend.presenter.proto.Coordinate.x', index=0, + number=1, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='y', full_name='ascend.presenter.proto.Coordinate.y', index=1, + number=2, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=293, + serialized_end=327, +) + + +_RECTANGLE_ATTR = _descriptor.Descriptor( + name='Rectangle_Attr', + full_name='ascend.presenter.proto.Rectangle_Attr', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='left_top', full_name='ascend.presenter.proto.Rectangle_Attr.left_top', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='right_bottom', full_name='ascend.presenter.proto.Rectangle_Attr.right_bottom', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='label_text', full_name='ascend.presenter.proto.Rectangle_Attr.label_text', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=330, + serialized_end=478, +) + + +_PRESENTIMAGEREQUEST = _descriptor.Descriptor( + name='PresentImageRequest', + full_name='ascend.presenter.proto.PresentImageRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='format', full_name='ascend.presenter.proto.PresentImageRequest.format', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='width', full_name='ascend.presenter.proto.PresentImageRequest.width', index=1, + number=2, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='height', full_name='ascend.presenter.proto.PresentImageRequest.height', index=2, + number=3, type=13, cpp_type=3, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='data', full_name='ascend.presenter.proto.PresentImageRequest.data', index=3, + number=4, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='rectangle_list', full_name='ascend.presenter.proto.PresentImageRequest.rectangle_list', index=4, + number=5, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=481, + serialized_end=664, +) + + +_PRESENTIMAGERESPONSE = _descriptor.Descriptor( + name='PresentImageResponse', + full_name='ascend.presenter.proto.PresentImageResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='error_code', full_name='ascend.presenter.proto.PresentImageResponse.error_code', index=0, + number=1, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='error_message', full_name='ascend.presenter.proto.PresentImageResponse.error_message', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=666, + serialized_end=777, +) + +_OPENCHANNELREQUEST.fields_by_name['content_type'].enum_type = _CHANNELCONTENTTYPE +_OPENCHANNELRESPONSE.fields_by_name['error_code'].enum_type = _OPENCHANNELERRORCODE +_RECTANGLE_ATTR.fields_by_name['left_top'].message_type = _COORDINATE +_RECTANGLE_ATTR.fields_by_name['right_bottom'].message_type = _COORDINATE +_PRESENTIMAGEREQUEST.fields_by_name['format'].enum_type = _IMAGEFORMAT +_PRESENTIMAGEREQUEST.fields_by_name['rectangle_list'].message_type = _RECTANGLE_ATTR +_PRESENTIMAGERESPONSE.fields_by_name['error_code'].enum_type = _PRESENTDATAERRORCODE +DESCRIPTOR.message_types_by_name['OpenChannelRequest'] = _OPENCHANNELREQUEST +DESCRIPTOR.message_types_by_name['OpenChannelResponse'] = _OPENCHANNELRESPONSE +DESCRIPTOR.message_types_by_name['HeartbeatMessage'] = _HEARTBEATMESSAGE +DESCRIPTOR.message_types_by_name['Coordinate'] = _COORDINATE +DESCRIPTOR.message_types_by_name['Rectangle_Attr'] = _RECTANGLE_ATTR +DESCRIPTOR.message_types_by_name['PresentImageRequest'] = _PRESENTIMAGEREQUEST +DESCRIPTOR.message_types_by_name['PresentImageResponse'] = _PRESENTIMAGERESPONSE +DESCRIPTOR.enum_types_by_name['OpenChannelErrorCode'] = _OPENCHANNELERRORCODE +DESCRIPTOR.enum_types_by_name['ChannelContentType'] = _CHANNELCONTENTTYPE +DESCRIPTOR.enum_types_by_name['ImageFormat'] = _IMAGEFORMAT +DESCRIPTOR.enum_types_by_name['PresentDataErrorCode'] = _PRESENTDATAERRORCODE +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + +OpenChannelRequest = _reflection.GeneratedProtocolMessageType('OpenChannelRequest', (_message.Message,), dict( + DESCRIPTOR = _OPENCHANNELREQUEST, + __module__ = 'presenter_message_pb2' + # @@protoc_insertion_point(class_scope:ascend.presenter.proto.OpenChannelRequest) + )) +_sym_db.RegisterMessage(OpenChannelRequest) + +OpenChannelResponse = _reflection.GeneratedProtocolMessageType('OpenChannelResponse', (_message.Message,), dict( + DESCRIPTOR = _OPENCHANNELRESPONSE, + __module__ = 'presenter_message_pb2' + # @@protoc_insertion_point(class_scope:ascend.presenter.proto.OpenChannelResponse) + )) +_sym_db.RegisterMessage(OpenChannelResponse) + +HeartbeatMessage = _reflection.GeneratedProtocolMessageType('HeartbeatMessage', (_message.Message,), dict( + DESCRIPTOR = _HEARTBEATMESSAGE, + __module__ = 'presenter_message_pb2' + # @@protoc_insertion_point(class_scope:ascend.presenter.proto.HeartbeatMessage) + )) +_sym_db.RegisterMessage(HeartbeatMessage) + +Coordinate = _reflection.GeneratedProtocolMessageType('Coordinate', (_message.Message,), dict( + DESCRIPTOR = _COORDINATE, + __module__ = 'presenter_message_pb2' + # @@protoc_insertion_point(class_scope:ascend.presenter.proto.Coordinate) + )) +_sym_db.RegisterMessage(Coordinate) + +Rectangle_Attr = _reflection.GeneratedProtocolMessageType('Rectangle_Attr', (_message.Message,), dict( + DESCRIPTOR = _RECTANGLE_ATTR, + __module__ = 'presenter_message_pb2' + # @@protoc_insertion_point(class_scope:ascend.presenter.proto.Rectangle_Attr) + )) +_sym_db.RegisterMessage(Rectangle_Attr) + +PresentImageRequest = _reflection.GeneratedProtocolMessageType('PresentImageRequest', (_message.Message,), dict( + DESCRIPTOR = _PRESENTIMAGEREQUEST, + __module__ = 'presenter_message_pb2' + # @@protoc_insertion_point(class_scope:ascend.presenter.proto.PresentImageRequest) + )) +_sym_db.RegisterMessage(PresentImageRequest) + +PresentImageResponse = _reflection.GeneratedProtocolMessageType('PresentImageResponse', (_message.Message,), dict( + DESCRIPTOR = _PRESENTIMAGERESPONSE, + __module__ = 'presenter_message_pb2' + # @@protoc_insertion_point(class_scope:ascend.presenter.proto.PresentImageResponse) + )) +_sym_db.RegisterMessage(PresentImageResponse) + + +# @@protoc_insertion_point(module_scope) diff --git a/best_practices/contrib/ganomaly/acllite/presenteragent/socket_client.py b/best_practices/contrib/ganomaly/acllite/presenteragent/socket_client.py new file mode 100644 index 0000000000000000000000000000000000000000..1e69b88cba5ad0dbcd83e0d1ce78dd1dd4803489 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/presenteragent/socket_client.py @@ -0,0 +1,135 @@ +# !/usr/bin/env python +# -*- coding:utf-8 -*- +import sys +sys.path.append("..") + +import threading +import socket +import time +import struct + +from acllite_logger import log_error, log_info + +class AgentSocket(object): + """Create socket between app and presenter server""" + def __init__(self, server_ip, port): + """Create socket instance + Args: + server_ip: presenter server ip addr + port: connect port of presenter server + """ + self._server_address = (server_ip, port) + self._sock_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + + def connect(self): + """Create connect with presenter server + Returns: + ret: connect error code, 0 is connect success, otherwise failed + """ + ret = 0 + for i in range(0, 5): + ret = self._sock_client.connect_ex(self._server_address) + if ret == 0: + break + time.sleep(0.2) + return ret + + def _read_socket(self, read_len): + has_read_len = 0 + read_buf = b'' + total_buf = b'' + + while has_read_len != read_len: + try: + read_buf = self._sock_client.recv(read_len - has_read_len) + except socket.error: + log_error("Read socket failed, error ", socket.error) + return False, None + if read_buf == b'': + return False, None + total_buf += read_buf + has_read_len = len(total_buf) + + return True, total_buf + + def _read_msg_head(self, read_len): + ret, msg_head = self._read_socket(read_len) + if not ret: + log_error("socket receive msg head null") + return None, None + + # in Struct(), 'I' is unsigned int, 'B' is unsigned char + msg_head_data = struct.Struct('IB') + (msg_total_len, msg_name_len) = msg_head_data.unpack(msg_head) + msg_total_len = socket.ntohl(msg_total_len) + + return msg_total_len, msg_name_len + + def _read_msg_name(self, msg_name_len): + ret, msg_name = self._read_socket(msg_name_len) + + if not ret: + log_error("Socket receive msg but name is null") + return False, None + try: + msg_name = msg_name.decode("utf-8") + except: + log_error("Msg name decode to utf-8 error") + return False, None + + return True, msg_name + + def _read_msg_body(self, msg_body_len): + ret, msg_body = self._read_socket(msg_body_len) + if not ret: + log_error("Socket receive msg but body null") + return False, None + return True, msg_body + + def recv_msg(self): + """Receive message from presenter server + Returns: + msg_name: received message name + msg_body: received message data + """ + # Step1: read msg head + msg_total_len, msg_name_len = self._read_msg_head(5) + if msg_total_len is None: + log_error("msg total len is None.") + return None, None + + # Step2: read msg name + ret, msg_name = self._read_msg_name(msg_name_len) + if not ret: + return None, None + + # Step3: read msg body + msg_body_len = msg_total_len - 5 - msg_name_len + if msg_body_len < 0: + log_error("msg total len is 0") + return None, None + ret, msg_body = self._read_msg_body(msg_body_len) + if not ret: + return None, None + + return msg_name, msg_body + + def send_msg(self, data): + """Send message to presenter server + Args: + data: message data + Returns: + 0 send success + 1 send failed + """ + try: + self._sock_client.sendall(data) + except: + log_error("Send msg failed") + return 1 + return 0 + + def close(self): + """Close connect""" + self._sock_client.shutdown(socket.SHUT_RDWR) + self._sock_client.close() diff --git a/best_practices/contrib/ganomaly/acllite/videocapture.py b/best_practices/contrib/ganomaly/acllite/videocapture.py new file mode 100644 index 0000000000000000000000000000000000000000..c58173e34f57cead944e2278687b0bb00c255ad2 --- /dev/null +++ b/best_practices/contrib/ganomaly/acllite/videocapture.py @@ -0,0 +1,376 @@ +import av +import threading +import numpy as np +import acl +import time + +import constants as const +import acllite_utils as utils +import acllite_logger as acl_log +import dvpp_vdec as dvpp_vdec +from acllite_image import AclLiteImage + +WAIT_INTERVAL = 0.01 +WAIT_READY_MAX = 10 +WAIT_FIRST_DECODED_FRAME = 0.02 + +DECODE_STATUS_INIT = 0 +DECODE_STATUS_READY = 1 +DECODE_STATUS_RUNNING = 2 +DECODE_STATUS_PYAV_FINISH = 3 +DECODE_STATUS_ERROR = 4 +DECODE_STATUS_STOP = 5 +DECODE_STATUS_EXIT = 6 + + +class _ChannelIdGenerator(object): + """Generate global unique id number, single instance mode class""" + _instance_lock = threading.Lock() + channel_id = 0 + + def __init__(self): + pass + + def __new__(cls, *args, **kwargs): + if not hasattr(_ChannelIdGenerator, "_instance"): + with _ChannelIdGenerator._instance_lock: + if not hasattr(_ChannelIdGenerator, "_instance"): + _ChannelIdGenerator._instance = object.__new__( + cls, *args, **kwargs) + return _ChannelIdGenerator._instance + + def generator_channel_id(self): + """Generate global unique id number + The id number is increase + """ + curren_channel_id = 0 + with _ChannelIdGenerator._instance_lock: + curren_channel_id = _ChannelIdGenerator.channel_id + _ChannelIdGenerator.channel_id += 1 + + return curren_channel_id + + +def gen_unique_channel_id(): + """Interface of generate global unique id number""" + generator = _ChannelIdGenerator() + return generator.generator_channel_id() + + +class VideoCapture(object): + """Decode video by pyav and pyacl dvpp vdec + This class only support decode annex-b h264 file or rtsp ip camera. + You can use command: + ffmpeg -i aaa.mp4 -codec copy -bsf: h264_mp4toannexb -f h264 aaa.h264 + to transform mp4 file to h264 stream file. + If decode rtsp of ip camera or stream pull stream software, make sure + the stream format is annex-b + + Attributes: + _stream_name: video stream name + _input_buffer: dvpp vdec decode input data buffer + _ctx: decode thread acl context, use the same contxt with app + _entype: video stream encode type, dvpp vdec support: + const.ENTYPE_H265_MAIN = 0 H265 main level + const.ENTYPE_H264_BASE = 1 H264 baseline level + const.ENTYPE_H264_MAIN = 2 H264 main level + const.ENTYPE_H264_HIGH = 3 H264 high level + this attributes will read from video stream extradata + _channel_id: dvpp vdec decode channel id parameter, global unique + _vdec: pyacl dvpp vdec instance + _is_opened: the video stream wether open or not + _status: video decoder current status + _run_mode: the device mode + """ + + def __init__(self, strame_name): + self._stream_name = strame_name + self._input_buffer = None + self._vdec = None + self._is_opened = False + self._width = 0 + self._height = 0 + self._decode_thread_id = None + self._dextory_dvpp_flag = False + self._ctx, ret = acl.rt.get_context() + if ret: + acl_log.log_error("Get acl context failed when " + "instance AclVideo, error ", ret) + else: + self._entype = const.ENTYPE_H264_MAIN + self._channel_id = gen_unique_channel_id() + self._status = DECODE_STATUS_INIT + self._run_mode, ret = acl.rt.get_run_mode() + if ret: + acl_log.log_error("Get acl run mode failed when " + "instance AclVideo, error ", ret) + else: + self._open() + + def __del__(self): + self.destroy() + + def _open(self): + # Get frame width, height, encode type by pyav + if self._get_param(): + acl_log.log_error("Decode %s failed for get stream " + "parameters error" % (self._stream_name)) + return + + # Create decode thread and prepare to decode + self._decode_thread_id, ret = acl.util.start_thread( + self._decode_thread_entry, []) + if ret: + acl_log.log_error("Create %s decode thread failed, error %d" + % (self._stream_name, ret)) + return + + # Wait decode thread decode ready + for i in range(0, WAIT_READY_MAX): + if self._status == DECODE_STATUS_INIT: + time.sleep(WAIT_INTERVAL) + + if self._status == DECODE_STATUS_READY: + self._is_opened = True + acl_log.log_info("Ready to decode %s..." % (self._stream_name)) + else: + acl_log.log_error("Open %s failed for wait ready timeout" + % (self._stream_name)) + return + + def _get_param(self): + container = av.open(self._stream_name) + stream = [s for s in container.streams if s.type == 'video'] + if len(stream) == 0: + # The stream is not video + acl_log.log_error("%s has no video stream" % (self._stream_name)) + return const.FAILED + + ret, profile = self._get_profile(stream) + if ret: + acl_log.log_error("%s is not annex-b format, decode failed" + % (self._stream_name)) + return const.FAILED + + video_context = container.streams.video[0].codec_context + codec_id_name = video_context.name + ret, self._entype = self._get_entype(codec_id_name, profile) + if ret: + return const.FAILED + + self._width = video_context.width + self._height = video_context.height + + acl_log.log_info( + "Get %s infomation: width %d, height %d, profile %d, " + "codec %s, entype %d" % + (self._stream_name, + self._width, + self._height, + profile, + codec_id_name, + self._entype)) + + container.close() + + return const.SUCCESS + + def _get_profile(self, stream): + # Annex-b format h264 extradata is start with 0x000001 or 0x00000001 + extradata = np.frombuffer(stream[0].codec_context.extradata, np.ubyte) + if (extradata[0:3] == [0, 0, 1]).all(): + profile_id = extradata[4] + elif (extradata[0:4] == [0, 0, 0, 1]).all(): + profile_id = extradata[5] + else: + acl_log.log_error("The stream %s is not annex-b h264, " + "can not decode it" % (self._stream_name)) + return const.FAILED, None + + return const.SUCCESS, profile_id + + def _get_entype(self, codec_id_name, profile): + # Dvpp vdec support h264 baseline, main and high level + profile_entype_tbl = { + 'h264': {const.FF_PROFILE_H264_BASELINE: const.ENTYPE_H264_BASE, + const.FF_PROFILE_H264_MAIN: const.ENTYPE_H264_MAIN, + const.FF_PROFILE_H264_HIGH: const.ENTYPE_H264_HIGH}, + 'h265': {const.FF_PROFILE_HEVC_MAIN: const.ENTYPE_H265_MAIN}} + entype = None + ret = const.SUCCESS + + if codec_id_name in profile_entype_tbl.keys(): + entype_tbl = profile_entype_tbl[codec_id_name] + if profile in entype_tbl.keys(): + entype = entype_tbl[profile] + elif codec_id_name == 'h264': + # if not support profile, try to decode as main + entype = const.ENTYPE_H264_MAIN + acl_log.log_error("Unsurpport h264 profile ", profile, + ", decode as main level") + else: + entype = const.ENTYPE_H265_MAIN + acl_log.log_error("Unsurpport h265 profile ", profile, + ", decode as main level") + else: + # Not h264 or h265 + ret = const.FAILED + acl_log.log_error("Unsupport codec type ", codec_id_name) + + return ret, entype + + def _pyav_vdec(self): + frame = 0 + video = av.open(self._stream_name) + stream = [s for s in video.streams if s.type == 'video'] + acl_log.log_info("Start decode %s frames" % (self._stream_name)) + for packet in video.demux([stream[0]]): + # Get frame data from packet and copy to dvpp + frame_data, data_size = self._prepare_frame_data(packet) + if data_size == 0: + # Last packet size is 0, no frame to decode anymore + break + + if self._vdec.process(frame_data, data_size, + [self._channel_id, frame]): + acl_log.log_error("Dvpp vdec deocde frame %d failed, " + "stop decode" % (frame)) + self._status = DECODE_STATUS_ERROR + break + frame += 1 + + # The status chang to stop when app stop decode + if self._status != DECODE_STATUS_RUNNING: + acl_log.log_info("Decode status change to %d, stop decode" + % (self._status)) + break + + def _prepare_frame_data(self, packet): + in_frame_np = np.frombuffer(packet.to_bytes(), np.byte) + size = in_frame_np.size + if size == 0: + # Last frame data is empty + acl_log.log_info("Pyav decode finish") + self._status = DECODE_STATUS_PYAV_FINISH + return None, 0 + + if "bytes_to_ptr" in dir(acl.util): + bytes_data = in_frame_np.tobytes() + in_frame_ptr = acl.util.bytes_to_ptr(bytes_data) + else: + in_frame_ptr = acl.util.numpy_to_ptr(in_frame_np) + policy = const.ACL_MEMCPY_DEVICE_TO_DEVICE + if self._run_mode == const.ACL_HOST: + policy = const.ACL_MEMCPY_HOST_TO_DEVICE + ret = acl.rt.memcpy(self._input_buffer, size, in_frame_ptr, size, + policy) + if ret: + acl_log.log_error("Copy data to dvpp failed, policy %d, error %d" + % (policy, ret)) + self._status = DECODE_STATUS_ERROR + return None, 0 + + return self._input_buffer, size + + def _decode_thread_entry(self, arg_list): + # Set acl context for decode thread + if self._decode_thread_init(): + acl_log.log_error("Decode thread init failed") + return const.FAILED + + self._status = DECODE_STATUS_READY + while (self._status == DECODE_STATUS_READY): + time.sleep(WAIT_INTERVAL) + + self._pyav_vdec() + self._decode_thread_join() + + return const.SUCCESS + + def _decode_thread_init(self): + # Set acl context for decode thread + ret = acl.rt.set_context(self._ctx) + if ret: + acl_log.log_error("%s decode thread init dvpp vdec failed") + return const.FAILED + + # Instance dvpp vdec and init it + self._vdec = dvpp_vdec.DvppVdec(self._channel_id, self._width, + self._height, self._entype, self._ctx) + if self._vdec.init(): + acl_log.log_error("%s decode thread init dvpp vdec failed" + % (self._stream_name)) + return const.FAILED + + # Malloc dvpp vdec decode input dvpp memory + self._input_buffer, ret = acl.media.dvpp_malloc( + utils.rgbu8_size(self._width, self._height)) + if ret: + acl_log.log_error("%s decode thread malloc input memory failed, " + "error %d. frame width %d, height %d, size %d" + % (self._stream_name, ret, + self._width, self._height, + utils.rgbu8_size(self._width, self._height))) + return const.FAILED + + return const.SUCCESS + + def _decode_thread_join(self): + self.destroy() + # Wait all decoded frame token off by read() + while self._status < DECODE_STATUS_STOP: + time.sleep(WAIT_INTERVAL) + self._status = DECODE_STATUS_EXIT + + def is_finished(self): + """Decode finished + Pyav and dvpp vdec decoded all frame, and all deocde frames were + token off. When read() return success but image is none, use this to + confirm decode finished + """ + return self._status == DECODE_STATUS_EXIT + + def read(self, no_wait=False): + """Read decoded frame + Args: + no_wait: Get image without wait. If set this arg True, and + return image is None, should call is_finished() method + to confirm decode finish or failed + + Returns: + 1. const.SUCCESS, not None: get image success + 2. const.SUCCESS, None: all frames decoded and be token off + 3. const.FAILED, None: Has frame not decoded, but no image decoded, + it means decode video failed + """ + # Pyav and dvpp vdec decoded all frame, + # and all deocde frames were token off + if self._status == DECODE_STATUS_EXIT: + return const.SUCCESS, None + + # When call read first time, the decode thread only ready to decode, + # but not decoding already. Set status to DECODE_STATUS_RUNNING will + # cause pyav and dvpp vdec start decode actually + if self._status == DECODE_STATUS_READY: + self._status = DECODE_STATUS_RUNNING + # The decode just begin, need wait the first frame to be decoded + time.sleep(WAIT_FIRST_DECODED_FRAME) + + ret, image = self._vdec.read(no_wait) + + # Decode finish or stopped, and all decode frames were token off + if (image is None) and (self._status > DECODE_STATUS_RUNNING): + self._status = DECODE_STATUS_EXIT + + return ret, image + + def destroy(self): + """Release all decode resource""" + if self._vdec is not None: + self._vdec.destroy() + while self._vdec._destory_channel_flag == False: + time.sleep(0.001) + if self._input_buffer is not None: + acl.media.dvpp_free(self._input_buffer) + self._input_buffer = None + self._dextory_dvpp_flag = True diff --git a/best_practices/contrib/ganomaly/convertOnnx.py b/best_practices/contrib/ganomaly/convertOnnx.py new file mode 100644 index 0000000000000000000000000000000000000000..683cae2b031fb11493ed9aef8a305cad34b30ed5 --- /dev/null +++ b/best_practices/contrib/ganomaly/convertOnnx.py @@ -0,0 +1,79 @@ +import argparse +import os +import time +import apex +from apex import amp +import datetime +from lib.data.dataloader import load_data + +import torch +import torch.nn as nn +import torch.nn.parallel +import torch.backends.cudnn as cudnn +import torch.distributed as dist +import torch.optim +import torch.utils.data +import torch.utils.data.distributed + +import torchvision.transforms as transforms +import torchvision.datasets as datasets +from torchvision.utils import save_image + +from lib.models import load_model +from options import Options + +from collections import OrderedDict +import torch +import torch_npu +import torch.onnx + + + +def main(): + args = Options().parse() + + os.environ['MASTER_ADDR'] = args.addr # 获取有关系统的各种信息，获取环境变量 + os.environ['MASTER_PORT'] = '29688' + + main_worker(args) + +def proc_nodes_module(checkpoint, AttrName): + new_state_dict = OrderedDict() + for key, value in checkpoint[AttrName].items(): + if key == "module.features.0.0.weight": + print(value) + if(key[0:7] == "module."): + name = key[7:] + else: + name = key[0:] + + new_state_dict[name] = value + return new_state_dict + +def main_worker(args): + args.loc = "cpu" + + data = load_data(args) + model = load_model(args, data) + + checkpoint_netd = torch.load("./output/skipganomaly/Mainboard/train/weights/netD_best.pth", map_location=torch.device('cpu')) + checkpoint_netd['state_dict'] = proc_nodes_module(checkpoint_netd,'state_dict') + model.netd.load_state_dict(checkpoint_netd['state_dict']) + + + checkpoint_netg = torch.load("./output/skipganomaly/Mainboard/train/weights/netG_best.pth", map_location=torch.device('cpu')) + checkpoint_netg['state_dict'] = proc_nodes_module(checkpoint_netg,'state_dict') + model.netg.load_state_dict(checkpoint_netg['state_dict']) + + model.netg.eval() + model.netd.eval() + + input_names = ["actual_input_1"] + output_names = ["output1"] + + dummy_input = torch.randn(1, 3, 32, 32) + torch.onnx.export(model.netg, dummy_input, "netg_npu.onnx", input_names = input_names, output_names = output_names, opset_version=11) + torch.onnx.export(model.netd, dummy_input, "netd_npu.onnx", input_names = input_names, output_names = output_names, opset_version=11) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..179cfdf8bd8129fcec58b016e9fda5913edabe69 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cc748e8c2747f0bd474e75f059e802196ee70b08 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ba079b564095a9ad6a126dda9a5ee457c9f35aca Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2da9d864cc143e8eb11e71c1253daaca218e12e0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..21b3de8a960083d7065835fce54976a5dba8a593 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/001_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ac7a7f233ff823ac4412a901781352403e1fccd6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4a8203ea8a02affb33505ea71ed91dd647730298 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2f11ca9cd3649968d19165e427348a6ea9e491b0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7457633c67e7c0e6df0b6e3f3364df03b8dedb00 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..93be0d4df74c9d5a9c3e7e2778bf54a505341ea3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5ffec7238e65cd6abdf8da3618e64fb97d9ed719 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/002_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f2888f9c7e9c60c7948c44b1e389bab555bd9e3c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3974c42eb8636c1a0e549eb871c0fd5061c08bca Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bfdf48de87eee38311730d8d1becba01683bcc8f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..85bf09b429e18bc1224dbd80108759fa80563d97 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4e55f73888e54767427dbc09d9096867fa2f8897 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/003_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/004_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/004_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..710605a98706494b2067e04c109040c687dd1868 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/004_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/004_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/004_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5ddcd9e5e79b28aa7d6fe999f624821fe9f1c62d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/004_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/005_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/005_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..012321fb4c531c7222f21f1f3a4881f71470461d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/005_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/005_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/005_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5dd61d1e1571b4a6671a1dddb5919287ce5f007c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/005_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/005_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/005_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..76071243c030bdbdfe64a083f49a609260efa721 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/005_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7aa61a5100de0737ae29d0b3828ca58fa1a38ff0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4615d60dc524ebe4ed691bf76b950aeb3b6a588c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9b50bc8043312223ac95193e1c8300f32f7fe162 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..38de13962e41f05e7d8abb25b5173ef40b01da35 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/006_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a2426ed24faa65614d43d1bff9a0710b672bec82 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0705f511775c91e83acfffc7e13d82bab547941d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..260c649c510e21bcc185ed035bb5d55eb72a046a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..960c55c267bd8b115a7dd04795662200b7f39893 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..57dec9cb4612de147014c9a7ddf1e76f8d0316b4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/007_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f5551f23ac07c2928e871412b02796f206eb4b88 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9c72c5f6366d89022e7aa093a5f891cb958fd691 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..76beea5c3b5144558ca365348a96ab54730a0287 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..320707962d069ee55bc406936979c849effa99ee Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e47476cc04f0bfa0c3341d688b8f1922757cff27 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/008_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fcc238ca3ae23fa8481d4bcf5a83d7c3fd4bedcc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1ed2c4fabc37048cec2561e1f8726aaa7f88f212 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3c9174113ce288a3210c0740e86e8a523bbe0f0b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..84a6c499794900758e0703f497afa9dcd6c31447 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f43f8fd074659e47e46b8768d16474643c3df6d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/009_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..485fe77afc4f3c7a3ea8b5f938e154bf0aa7b48e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..105a5322675aadd291eb3ed51bf9ac40230e2ad3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f7cda4a4d488d5efa5a2c0c56f5e8f82b4b867c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..be62eb429fc4b21832d0c69778ead0752a2d6060 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ff8cd83dcd5276320d15b97c2c7c63d61247e57d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..94f829ae791215f39fcd678e7380272cd3d60582 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/010_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2ffc41adac264aa1920382c9655f71d1b2a5b259 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3f1e9432a5d8a44276f32ad4f3f9e367316ccc39 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cd44601c16d5eaf39980d285ff6bbfdc50cf4c99 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..79bdcdc52884c8bdf39ada766997289f361e8f47 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f6d1ded0198ff357399a88a2ac838098e41429a9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..035bf5b8e78d6bbeba257dafff8e9628a64b1266 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/011_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/012_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/012_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9becd1dea2ea5b74eed45b88d06a6b7b6314723d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/012_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/012_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/012_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1f1b6978db06697c6f7d55725c6cc8a6763f058 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/012_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/012_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/012_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9e8fcd801d2179cc9471deeca8f7baaffeaf4e21 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/012_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/013_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/013_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c67d33706d687fea15e47982cc2b34517eebb9f5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/013_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/013_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/013_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0632d144521e9bea67ad921dc6f3ec4cd355e035 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/013_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/013_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/013_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2f4282026ee3f54c8a4504cde925502a165b36ce Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/013_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fcbbb904b92e965373398f081b654dffeedceffa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1e60dbf682ea2a4c861f54c7a82c53fc31f03730 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..15b2d1c08f4776f41d65a5d71fc209bd051f8861 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6e88df098e85b916c873aa244acadbf45b001597 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e3785bfbe2f1f265c07273b94a494704f4473edd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..05fcc363f0137d27950fe2ff3308a7111e85f86a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8216598cee352ed80e4b8753d15394293b76c7d3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8f4adf180c503b3773b810e704b1f3e515b1567a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/014_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1865385a860b9bd0f22b1ae93e36a20c42bb1e08 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..be7815743b034874d005c082cb996af65d60fe0e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5d9087abefe1d84ba9ffa9204dc17c42c78ebb1d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..baca40dbe1f28529d2f019d6f0bb92c79acd8e2e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1080cc4ef8e7aef0c82345160cac4c274e6b1bb5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..758d2dfe7fd5e6eca0f7127463241d3d9d568c73 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ab987c1559f239850daf6411e964293358ee5be8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d713d0f1d5340b7fcbf8451fc18dd33e113524f7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fbb2565b2fa79002a1cd36c503662c30a7800906 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1dc62706f83f0c469ae48e1270f9727ac514e3db Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d6bcc024aa4f382a9ec1e242de247b086b2b2d39 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/015_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d5eca69119816fc801d878275a8dee2f319e52f6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..03a09bcae698a80a7a85271ad2291ab46306f34d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1a855f49eeec8c90c39a15a343d99f9103f10d4c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..165dc3e51d108aa922f18e9bae4c2a9893801814 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..334706a0de26761a916673708f0a8f6e3118bd48 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1bc785777fcf29d1e4e7abe80f73235cb6ed2a9b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a8e201f815d1b1a73cd0b4634cb90ee7c3986fb5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3cec8d08362d1d91f09b7b040517cdb487aafe5d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..756ddd6d8ba0905176568461c2fcb1e93650f6b2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..43551e74a3e127379f900f1fb1a7385bede9bd4a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5c9470af54d66a734c4295234bb9c2ce3e5089da Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1ea0a2f4d2d29d907e0297bb8021517553fbe19b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/016_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e7798b4b7aae70f82ae90b35fad578b920b74a95 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a4d684fe657787d2a05c062606627b61f6d465fa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8d53ccd41702b2e062a013ceb4c207cb28132704 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6b14c03d3d1d4cb76892f1a4c5d6d62273be0261 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bc0b9252d981f9c6f83e4515102cafcdb6cba69d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7f556a0e1e494bc986f6fe364c1ba2cc775b6cc4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8f6af0904c995a4193e45e03bebab4cbd134cfb6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..74512f4802a523f7848339267b73b9ff68145863 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..33eb39f3bde0d63b6e2dff678085aabd94651be3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f4dd9c4dcac4870ca0c2760c1891efedeed03e62 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5ccefb2138fbc5c737480fa578db52866b98372b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b6ee2f37c2e626a9333e4d4774097c308ac3b16a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/017_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..46243d351c7d3b796eaf9eec0be217bf68da8928 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b36400718de808db9045a2c4c895b1709c5557ac Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bd4ac6cd02b42ffd5079525a75565b414c114145 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5f27e90f58ba397407ccd4f5b374ad1a18be4a8e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..93d163bad1fcb199a461ca5f29f3b9f838ea9aae Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..862d38b6e376d959eb9f0aad8f836b8bc7cc12d0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a4046f0061a368ecd06660e98cc98acc7d329e9c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6443060af8d87776286c6a3f7e122ac404b93030 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..095dc2cf5ca9942f38aa7049d2911d50d5be96a8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..264fd83fe55575ce5fbe9e9708d0ef955980a700 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..11e9f4e1e06ce1d62e3766f851be511d413b998d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/018_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cb96330cbc304b40459432c695516605cee70ece Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3172f0ee21e3373df01947fedeb8df9fcea14235 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f8fb8558dde07cefe21381624a5542f50d7d5278 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0c5991f15a262c194d35316748d04de8be7d01de Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4c12ace39cb80b3be9202604a99deba556be73a3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ba441d8b73ece1f60b180f5d263ce3da140f7fd0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..42b9c64e638fd352dd4a72286c4b8afc33b0f33f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..699f99fd8b7307dbf0963104a821e366055747e1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bdfa7f0ecce7a9d22385d9d3bfc324d48e980c85 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..32d2c10ff97464c543a9af8f955df9460175e2b3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b343d3617c8b52a5f865a470ae95cd87619c9ebc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/019_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/022_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/022_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3d4bb9fe4fd6af68d43e56eb586b6f18f407a3e0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/022_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/022_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/022_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..933233050506dc4f8ea6a64192f9aa755dab470b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/022_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/022_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/022_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dcdb0635c3b60448e9e0a234203e6d0c43a42ce6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/022_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ce1a1026bec340252da9a1f58a2d255b7658fec5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fef4b2bac093b65ca469ad03882ec87a42c3fc34 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ee5f32938e1492805d50bedfaf4f3bc5a21e23e6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f3fc95218df571435c03d208db4510ed7e051b05 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..486df42f8f652644077578e7c3c9b2f7dac31ce6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..35fa2b1cd4bf6a3984a788e014a58a18a81526df Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..13d143e60c7de6aa52aeb967dbce0a91523cc833 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4f6141751bfd4fc228a3a5f3666656d7643a8788 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..45d45eb4e4d87d12568df07ffce69251d39448ac Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7e1b7a2982db382277002f1d7ef6a6ee9bdcc602 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..10f6ba9d81ec0db4b82cac40bf992834b16374b7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/023_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dded5cbf1cf122cc494ef63d8619121c08c275a3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b6b15f080585a127444d75cf0e0c97bf0986a020 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2f2d4944d051842aec69da82e5ee36706ae25e3b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..01fb487198df188a9f36e13961c98fcba0046a9e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5f091823fc5497278823850f08242be1fd0911a2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dab205bf4749b68babc84f31d0b2a3fae3ee24b1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7e4407de9d22b72e2546e1480942b66ea232480b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f7f088f0b7e2b22673ebdfde5b99e6308e781be7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d7fe0bccb710e1c1bc7b6e98a2d5c17daec863d1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..759992b7e8ebe955abe23d2dc69db1e4a33868f5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7f54dc1670f4df9bcd4b6cc755611fea7375f0b8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/024_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..17465049e2ed5c45cd4376652d01c2fa9d7ecaa9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e819f3069aebe7d95f53178fc2cbff7f9bf7395a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..96d7d663963bd6ec89e378ffcadf9725119bb35d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5e23fc3eaecb8fe2dbd78758024160ae0a9a09ec Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8fac398c03a419981ff7531e7985e768553c716d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ac6d0edd08b974e3a248f353e589bc09436b9fd3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6889f924a426c0bc1c0c176f6e47e2af63299608 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..722f9f5e7848657dafd5e2989470eaa567834f06 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..92affdad7c667ce98bc91a1889297a0cc045467c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69fe8d7f3f4eb5078781830a84bb07a915e1781a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6cfd0f7e145cf659e44ad979156a5afca7f11e5e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/025_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2cb0a7c078858f76a3f90012e4c8dbb718775eec Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..47819717f8f451c1b0ddc7d36c1b6a19d6311ad1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fad8c10681052daa10e6e124e10662bb392660d9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..473bb1fb3097562ee2a8a96c6e795d545b0732ce Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..93b64566408d6714668c4bf382cdc0d7c1da24a4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1cf073568714a3ac40b9e845d5821ed930f9c936 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..42c03d546611eba2ede2b6e46e69c320576ffaf6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..94df31571a09f1f88b73cdc9033409fc22fae1ca Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..25bbbb4f970346a1dbecde47e77c1ab40d1a8f73 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..16fc90a91cd9463f02f1f28b08793d264f429a42 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/026_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..845302b7ec22f233869516700196a96db4615243 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..56db28ad6353152dfc4a35b8b7c848f5072acbd6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6a29563d60a634970e1404bd0009f875e91c29c2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2f9321b691ff7740dfeb1b8c6db32a8e63393b20 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fd8d797a658cf5f1fa41b47468cfc36efb57f9a0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..178fa5b63e3bd473579865e466d3471887e932de Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aa69cdadb303af31377f85067897e46ec31b9ddd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2e6f15d11ad9888271505c6ff6993a68bebe67a4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f31776fe14819c5cff7b2ff5879444af45c1dc2e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eab2e5f6432951d792b9eb26a887a68dbe7030c9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..93e307f8f8ab791f8e176359484151a44f149bb3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/027_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..88610b9185063a20cac78690b6a94bf9e009f74f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ef9997ffb35ce916069f6d03d4252cf493332d5d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..64556bf13c50d983b2a0d4580663262028c4c6b3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..166b843ae79389ebde1c5e2f6c68ee1c50337b02 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..809a3eb1f684c78a94a9faddf61d2be69d351965 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/028_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..435fa0a701cfb135a081175426a8d23e96583ef8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..947dc0a2ff85998ac0e0a054b3d6f4f6148ce469 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..502c149d6c56c3c68783faf8a1be6bb6b8b419d1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d026a09c9e451cd012de4fa0b0584ec0b92c5293 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fe818016a80ca9b7261b6a6a83521eb28afd3b99 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d4fdf419eb8cad8fb32e40daf133ff9471f41ab1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7ec83478e91480b5f556799fa6bc5a3fad2455ad Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2511e93d269b03a7ddffcd81d808d2bf35aa92dc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/029_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5a7ae80a60c1f76507da87a0626ca714aae4c57c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bc2524bb7eda8a39ba6e53611c85880c6ea22a75 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a0d773e4d0d86fa78dd21096f568472d369c11c7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..430d9368823ad097542608055d5e46f8ee340bba Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/030_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..13c8ba011f31913ee8aa69acee5b3ddde5dd5de8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ca6cd08a3493ec0338fb4c22f749b6f79e2e7161 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a80d56847c979ce697fb98c93cab3e490d5ae1a8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f2c7ce4cb9728884942ccdcaeb4fa288f4f8429e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0e09d32238e7bd69a0792f8bc2263f65462d47e7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..46a3a334dee25d73dd2668cae8503723e2e516ce Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..17aad8d317e040f4b6cb902521d053f2d553505e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4f609b884cc95ad89bc1be8051616b40b617dbf2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7955f771280c62dc11a3442c9a15808f6132ee35 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/031_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2932299d68f3a1bd3b852bfc122038451c615cdc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d7b1edc450301a8111b01088afb4d62fa7995d0b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..53e0d48a502fcfe9d2520bffcdc5cac2fe360103 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..00ee95a2394a163ff20de07772e8dd942d75f1d8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8e61e06f30a589dc637a281d2d6f4448a6bcf0a3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..70734c76c7746210e46372d9a772f64572a38d97 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..89503fcdd17ed450450269c63b787363b9d50fa3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b854691e662ef3ffee25826df7dd3b922ff9412d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0d20da9ee0106a514d855d71ad24f6d339a1b3de Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/032_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3f6241a161b8c31e71724b16bc90b900ecf1b8e4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7bbc9f40868b7a1a7f94f9ca68d350941353f397 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9c289d34c35558f5b5790cd4b08dfc51bc57ddb3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c2e455ec908f881fa0ceb6a3a0a0a122a601bbb5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0c4b6ffc5c90d4a04953bbc871bede4dcc3f0a09 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d64b179172fef014f5493bafe7268f72b55475ad Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..af0a67b2761961dc2df62e8a0cd1f23acb542ec5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/033_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..078b24744500f84b82f7122d8c54c4c4b20bdba8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9b084285dee647430e1df3bf17ed59fd90eca4ad Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f1709373c9c89c843a8cd43efa61118389b844ec Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dbc2fe05a7965736491b33967199ae11ca6999c7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9e116273c5a6da4e8d5dccd3618f21768cb77d9c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b53b4d50dbcb02e89bd344efb99a0c468301196e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..af149b9efb9f87b95794a649af6e51b9e5df8b59 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/034_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6b231a428ef616f6d6876abb651f9e1877257d5a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..772ba7fadd067f5c35bbb4e2fff6289d7eaaf5f0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d79c77ad9da6d8db693fd596109005b0780fadef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e18d9344eb508f6c4fe5c5b28bf63eb61e6c516a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..70f293be14f64aa861a51f15e2ca00d9a5cc0aee Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..307979c9dec0886a9be3b923e2c13c4f16cf7ab7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5fee8acb7fbc16101ab4122c13c2f285ff462b1d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..00761755b56749208710101159b80176e0666c31 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..948417e0811e965684226e755be61fa499454c36 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0a9586c511a097605080ab408b5980ad35fabdd7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d69d1a78deaf4d60527a3bd5154c8fabaf4591cb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..19067b923612f64115a93c6452524726b8c4ce98 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/035_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5c6af39ba917e23dd9f6c73e6b8ba23cd98d0cdf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ab8367fb0c93a117406c12df4ecbfafc4a70bac9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f5462a50d1a1566eab62bed7680ab4e36a19a49a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6ad4b453f85a7705f2198c14945ed80c6b1f5206 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..07cdc1ac0dc3828ff5d5aa9b21202539ce17f651 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..956ee0af522fe23b5f9d74ee8e0dffa8814eb241 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..96c8db6f108df2046d7586ebb039e2be315ed88a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..874ff1920858d779dd98efaacc3e2864cc57c7ef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..24dbb06afd39a8dfbd05af508b8a80526a758d8c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/0.normal/036_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/001_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/001_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5d25415c0db88dbf94c381be02b2cb46a8299a62 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/001_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/001_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/001_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..270e2861da7dc020b4fb35e23139b60b0ede688c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/001_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..95c930355f13a9e7f24d5a9bd7fc87884fc648fe Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f123d091152b41b91bc203e88ff8055abb850e1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69c4039f612a6c274f5c09c1502c3efbd6c83ba0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bc9e361e7740d1a274ba96a4e3291112eb6fc549 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/002_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0f107b2f9ca9494742120d7c34077d79f851d2aa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..31390d021efff5b02ef49a23c50edd11a4feef42 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8c9f997db0a2f3170cc1c1235983f44643cc20c8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7506b8af8320263b711b903983693f1977748ed9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/003_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..76953c89da0f464f051e06374765c1179dc735ef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..213f5a9cb492e4883d2befad0dfeac5be145d2ad Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4aea947850c85135568f6511e09d2496d6ada7d0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..97e1f55a4bad283be8988dbfe6693b30c8eaa219 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..117e3d2b3d5b6d9e3ca873e7a57076dc5f67ae63 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/004_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..54fa4013b5ee1946cea83c079a24fa67a153a75e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f52ef136423626b3cc2e5c84fd07603c23b05927 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fddc8013e11754f15b479a5d2ee2fe7290a02732 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..55eb8cede5d664b652c953ec968533341c6ddfbe Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0cf70609eda89544cb1eeb6df4c5568d9303e710 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..abaa1a54081e385c6e1d798d884932a2a7e6bd26 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/005_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..341dca228c94644b1406be8230fc59630e9cb639 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6b77df3506b4db1eb1e1fc3af1fa8baed34cabbb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..36fe8645317742820db38a3865d47a9b010789ad Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..da9b9fa87d7273227344fbb7e811c500d8858716 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8296a985c160646e7a0ad56fb4d1135ff679e67a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/006_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/007_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/007_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..10fb4b6027b1123c3fff4b34d68806978ffb057b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/007_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/007_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/007_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f3a731a8f0d1bd49619ed6071d274aefebc4d998 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/007_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/007_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/007_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..75f375ce493569e875abfb333146bd0223656de6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/007_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..32f8fd920f8e36f42390db99c037f8943d4fed0a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..06e7fb01893394152e3b5c88b140a8b285fbe1bc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..019c12c586ab64f4b5978e665076d911d57234f1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b2621623190515a634fcee5db44ada1630a7eb7c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8f58029f782a9502f74d8f07a2ae377a49e2ad6f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..485a5849a7fe67b72ca7f29e4d901eff49659318 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/008_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..976aa9bae48dcb01c87030288f25b2c619a2afd5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a3573780bca8bc20a629095a30f2e8098b649d90 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c8a5baf840be21dc4ed7a57b7bfda2fa822c05f2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5b83ccb582f220dae255214a7d9ff342eb270956 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fb0d543cd7c2342c577d4713f31c38d8854ca17c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/009_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/010_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/010_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bdc93021b4a634f384bbe13ba00762b54687a486 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/010_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/010_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/010_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6b86ab132182e651cccaf4a5abbc82423ab259dd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/010_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/010_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/010_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b3492bb0f0149b03cf9371fc56ecb6ef3dd37ae1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/010_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2ec00136fb1a07296fd213dd30f76c1a9c03c1ef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d3621758fd448c62220e86a841524c6216bd9d01 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2a8ae7d728bab3bc072ff5ccf71bb2af5b653c7c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a4a83b380085886f63d02a82ea0e1b1bdb635ea9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/011_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f3a903eea0c449f222c67ffd44de13f697bd2c4e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..da7100539987dde5f14d6660480bcadd53cfb4bd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b947bdb1992f17b45fa611776a3c45240bbd50de Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f77aff99069353ca5699e8affe075928ec5a8c6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b8b8f0b25782088313025e5d40f64bac4bcea873 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c635bb012c92c382056b8ffc1f1df407bb933d04 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/012_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3b40f482b6982fa87b5069af9097bc5e024c75f3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b914003905f6829ea8add37f0a895f6020b516f8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1c023ce5cb513fdfd5bcecccaf14888f9754c28 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..920410a2bdcb2d66106a94cc3dacbf47862ad77a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..569c35e6f9764ff5e8e53b9842a69a7b65f08d1a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..589a0c3ccd2a52b5943345231ffff36e64e16acc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..99166e0ff5e78fe1e617fd419475be2e04a669bb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/013_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b40013cc0e0db0c502fa7e24a124f089f986a9a9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2f6aab0d24dfdc9122ecfe235e3310f5462c4d92 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f8ed61094592d8e5f4d40f45c6b7ced6dfa11923 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c1f1accb755df4aa642445dd71c785612d497849 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6778bd643ba253252e3166c6974f5c0227b599b8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2883823d52a1d28b8a7c3e0d31b51084d4f76e55 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0feca2433b17bffd9d75ccd04a6002a8122b7bc1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/014_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f67d2d6e335887c3ea9cabe8dd7a66cd39eb2761 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..930b3697e1fd63e4d22e6a7f3ae5c19662a7a5e1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7494bd37461744d152a5f67902ceefb52b71edcc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..684b8afaf9726e744d0529ebb773bc2d284bc60a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/015_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/016_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/016_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..feec48543e0832d72094c494758efcab8e253dd5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/016_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/016_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/016_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e6df521ed7202e8afef8f2e8972376efa58c8f9c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/016_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/017_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/017_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1098ea8107bc18bf607833fead44231386a59f2f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/017_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/017_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/017_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d3e39216835288c4344ff4bb15ac4ab19141330d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/017_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/017_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/017_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1bd476fe7f67f4acbad45e64398dfe61616e40ca Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/017_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f3a903eea0c449f222c67ffd44de13f697bd2c4e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5e97a0e722cc95ac0a6cb4c09ab6cd4af0675ce7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..da7100539987dde5f14d6660480bcadd53cfb4bd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b947bdb1992f17b45fa611776a3c45240bbd50de Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f77aff99069353ca5699e8affe075928ec5a8c6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b8b8f0b25782088313025e5d40f64bac4bcea873 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c635bb012c92c382056b8ffc1f1df407bb933d04 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/018_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fb0765bd405fcdf19858954dad952def25091563 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..74abdcd4557c342f39e42d2e972709941ac323a9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e0c77153325011dfe3e405a95b402d13decf4ccc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..141cadc071ca8bb2ec867dcc6ef777ea9af0f727 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..56ba53daa689ddb2256eec15adb4ec95859e4e20 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/019_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/020_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/020_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8e2205f8917f497b9062de9f423a2d02049a657b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/020_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/020_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/020_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d572b4a479a9f7f1f6558ab0bf1fc06cf86fc61f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/020_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/021_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/021_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1918a18a6e28bec580c8304633ae5b19a10623c9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/021_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/021_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/021_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..976aa9bae48dcb01c87030288f25b2c619a2afd5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/021_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/021_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/021_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5b83ccb582f220dae255214a7d9ff342eb270956 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/021_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/022_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/022_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e5e8607411a2c3a5221dc34bb4f0a14370fc98a7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/022_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/022_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/022_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1c3e09b5932cf0373549614e7c224ddb65be35fb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/022_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/022_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/022_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4e57bdb6aab9c52f6e022e4e4f607d7734fba66c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/022_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..af45727943c12d300112873af405491ac27bbee0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c80c84bb0dc90c7511ac59717cac604b0282cb29 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fbd498a2c5e60b8d9af9d4ec5902f85c30f2f81b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..514fd41bfa9c61f16e7a27bdc6fa500cf8ae2b11 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..38390b3d533e6197b6fe2235faba3b9974dff89f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/023_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1b9ba091771d74c695fce8e6d67d599dd85748e1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..83b38d2e78f2c1d120461264f155cdf9a9552cb4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c69fadb0c25216ab0e3755b23a0efd9aa6558df9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..842e4330955918e9df45fe398af4a3cfa915436e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/024_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..10e33fb97587ba59aa38662875dfab5d46fea49c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4a8b90b02208bc539516b112642d8b7c497b4ccd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..35849686db613766ec9d4f4458040d230d147ed9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9cf8190e7fd1fecea7ba07465a9b57951cce2462 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0f2fffc12858b202643d5ed0d7e902f637ccedd9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/025_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..20264182841820bfaeb65009b02698a8e4fb93b7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ca8771013dd3299e624edf524f85fc2c10dd2bbf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..111497d43485e16e2c57e8d42c030a7814c1f4bb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..762613390a255efb819c290088b82c17a2840709 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/026_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/027_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/027_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d48bb0c2f018ffcb85c6264c18c90c5132db11fa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/027_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/028_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/028_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8334b04f40c90e554661103c05551746b4cb0461 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/028_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/029_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/029_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2b048e82bf861b76e0026c9fa4e089da02abbe45 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/029_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1b9ba091771d74c695fce8e6d67d599dd85748e1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..83b38d2e78f2c1d120461264f155cdf9a9552cb4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5e97a0e722cc95ac0a6cb4c09ab6cd4af0675ce7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..842e4330955918e9df45fe398af4a3cfa915436e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/030_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/031_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/031_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..76dbd7d49967a21fe1577077b88470fe07afca8c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/031_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/032_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/032_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f1bda1ed76aeab3d2ca70393a6970816dd77d3c6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/032_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/033_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/033_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c5e888adb250124c59b0ebcc0acf7ac4940f30c4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/033_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/034_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/034_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1b9ca9cc92d24b722682ecee00a7714374b574d6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/034_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/034_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/034_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f76e0924df1c9c96ef414ec1ce0cc2ed78cbcd1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/034_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/035_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/035_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b56f7ce52d292d97f66444766c85ebe34b020c56 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/035_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/035_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/035_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..31657d69fb5cdadc99d774bc2eea8077298dd4d5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/035_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/036_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/036_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0810eb7c85fad8f1a8dbcc068bc13d1076bacd6a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/036_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..341dca228c94644b1406be8230fc59630e9cb639 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6b77df3506b4db1eb1e1fc3af1fa8baed34cabbb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..36fe8645317742820db38a3865d47a9b010789ad Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..da9b9fa87d7273227344fbb7e811c500d8858716 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/038_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/039_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/039_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..10fb4b6027b1123c3fff4b34d68806978ffb057b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/039_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/039_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/039_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f3a731a8f0d1bd49619ed6071d274aefebc4d998 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/039_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/040_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/040_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5d25415c0db88dbf94c381be02b2cb46a8299a62 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/040_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/041_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/041_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..95c930355f13a9e7f24d5a9bd7fc87884fc648fe Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/041_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/041_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/041_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f123d091152b41b91bc203e88ff8055abb850e1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/041_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/041_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/041_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69c4039f612a6c274f5c09c1502c3efbd6c83ba0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/041_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ad85743ad26fe9e831a46c49382407ae7c6e3483 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..828fed2bf450af4758a930a966c7d78545c9f0c7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8c9120c74c55ec8131a068c8f0842fab8ceebc6d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5bdb85397a4c25172404bd73b8dfb2d0a6e31851 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/042_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/043_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/043_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7583c8e1f45979be20fd711ce52da9386008bd04 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/043_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/043_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/043_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..610647ad32006f5f41bcaa1f1fd8c9f48a4cb9a1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/043_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/043_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/043_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bb891290c5ec671f030de92287ec1b25d5fb1710 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/043_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/044_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/044_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ed017f7a1daec6aea3842b2ba4b803ed845fab61 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/044_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/044_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/044_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d73c094ebc872e155bb3910ef6bac2b06967ec1e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/044_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/045_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/045_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8739ba62a28e9c8b696e90b01da87992a3532c91 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/045_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/045_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/045_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..de953048d191bb69fa02c72c5d3218b17e67e947 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/045_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/046_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/046_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a91d46369c4298b93f4592ea20e9b672202bed9f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/046_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/046_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/046_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..70ea5f9999374069c2eadcd84de29e5f27dc29c0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/046_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/046_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/046_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d9ed3275355b171977a1b3a038c1e142a3bb74e3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/046_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/047_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/047_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ac68c297c7cb72e939e381ae994b77d8e8030f9d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/047_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/047_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/047_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3e01e78fe09c36de7b49dd8a94e675fce0fd7e14 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/047_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/047_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/047_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2b69be5fb24933fb47389e425e4f96d0658ce7ec Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/047_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/048_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/048_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b8bdd4318e82d6ce7bd03f015f46168cf272f28d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/048_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/048_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/048_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3e8e08fee34c85bb1fadb45b05bcc356a7087774 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/048_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/048_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/048_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..53822f1214e7770d352e488ddc1ce6903e0f5779 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/048_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/049_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/049_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f3d0467a83290f043d350c60c2f7db714b9965c0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/049_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/049_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/049_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..da81699621fcc66560e7186e48e13934ebf535f8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/049_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/049_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/049_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..18fe207ba99aba348166e531b900aa0b991037af Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/049_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/050_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/050_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..89d1737f06fdef687af402553969a3305e14a491 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/050_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/051_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/051_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a74bb0aeb157da5aa3c9b18c88ef0c718fc9e16f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/051_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/052_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/052_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1063d5cd8b6c3688459b99dfb6a694314151e59c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/052_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/053_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/053_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..af45727943c12d300112873af405491ac27bbee0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/053_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/054_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/054_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a322f4e3cd2f2930bcf8f7e8ae08ca92265d2cdd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/054_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/055_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/055_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e7ad6a5fb0c8113be44ad62c680835b77486a848 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/055_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/056_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/056_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b56f7ce52d292d97f66444766c85ebe34b020c56 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/056_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/057_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/057_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4487c8585fad1cda9e30ebd762b36bf4dd3986f0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/057_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/058_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/058_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c69fadb0c25216ab0e3755b23a0efd9aa6558df9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/058_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/059_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/059_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0f2fffc12858b202643d5ed0d7e902f637ccedd9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/059_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/061_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/061_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8a1f7dacce02e06f55d76cf55077e6a7205eedf8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/061_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/062_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/062_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..975fb17ebb55ede614a511d26de23064308e8349 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/062_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/063_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/063_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..edb72be581e817f7830bd23aadfdfa1c1b1053f8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/063_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/064_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/064_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1a0c2f6245ff8392a564c66e1ad38ae8feb94d12 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/064_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/064_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/064_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..411c1ae8691cad89f6444a1d066a69e2e833e7e7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/064_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/064_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/064_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dff591482de9a73c85a7efeb4edeab99f5e38da2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/064_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..76953c89da0f464f051e06374765c1179dc735ef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..213f5a9cb492e4883d2befad0dfeac5be145d2ad Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4aea947850c85135568f6511e09d2496d6ada7d0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..97e1f55a4bad283be8988dbfe6693b30c8eaa219 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/065_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..54fa4013b5ee1946cea83c079a24fa67a153a75e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f52ef136423626b3cc2e5c84fd07603c23b05927 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fddc8013e11754f15b479a5d2ee2fe7290a02732 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..55eb8cede5d664b652c953ec968533341c6ddfbe Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0cf70609eda89544cb1eeb6df4c5568d9303e710 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/066_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/087_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/087_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5f33cf834812a3efe8ea7e1c4099528a49865824 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/087_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/088_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/088_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0630047b6ce1f547a23320771cb76947a00f73a8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/088_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/089_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/089_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d056d4f86ce12f3488829fb68f0ce5aa54b5ce59 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/089_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/090_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/090_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b28eddaee8278327802aa297e5df1f55209df91e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/090_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/091_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/091_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..929d2d9349f5b1f41ee310f5832e66a601673e69 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/091_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/092_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/092_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b0499dd742a52c55bca5925333d362ad85d9a8dc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/092_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/093_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/093_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..479ebbd05064163427f9a5089e589aa99458ca6a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/093_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/094_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/094_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9180bdfc803e58e3498068ef645cea56f7331e45 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/094_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/095_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/095_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..502eff4815681883cc506c6c84d4d038fb8c300e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/095_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/096_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/096_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dcd10c23299521cc51e1428f2724493bd3a32273 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/096_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/097_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/097_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a3edb8d154bfffad7d4758acefc7cb1a5c8ec483 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/097_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/098_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/098_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fe8ac0c00a79cda34a931eddfd4790ba2975cd11 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/098_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/099_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/099_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f15feb2ee6271fb4ba6cdbb8dfec09da70d67644 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/099_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/100_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/100_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..88305560f4b9e0a1a460bcaafc58b43cd6cbe6fb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/100_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/101_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/101_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c39976604e2fea040c0c87b4c80f82dda582a0c5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/101_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/102_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/102_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9e4fb721f2824326fdc563a9eeec2deeaa9fbc69 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/102_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/103_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/103_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f51f33548b761f99aa1b6a0cccf4be8baa242ce9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/103_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/104_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/104_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1fd14716d142c12f2a77900d13ebd3c00025e996 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/104_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/105_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/105_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3add5ff384f2d885f97c83517b361827e67ec33b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/105_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/106_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/106_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..85afb4654634fc17eab393e4e56d572b11f408a3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/106_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/107_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/107_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a44829bc62244f8aecba7669d654ab238c5a02fe Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/107_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/108_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/108_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dd2ae10d74baaaa98aa980ea54aac42109bbb5fc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/108_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/109_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/109_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3f1ea7f925c6099bc02f67a63b68ae4a4dafee6b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/109_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/110_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/110_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6185f8a6a759bbff657a8e7a5ee5604f7da03a84 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/110_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/111_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/111_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..98c214cba2db32620f7701a1b31ce5ebbd6628a1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/111_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/112_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/112_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f5da47f47141e169e7f8a57f9f42b24bd0c112e3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/112_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/113_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/113_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fdcaa8132914180ef47ad3068f4d624852a34e8b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/113_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/114_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/114_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9d8152477704855aab7aee2486b26202d021add5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/114_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/115_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/115_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f5b74f92934476bbb58a7c1f3462c9d5bc580809 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/115_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/116_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/116_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..368560187f0b5ab9b3f51e29d68c2026e27a7e69 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/116_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/42.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/42.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0816fe6e9bfbd3ba8586cbd7b11a0dc0dfba79d2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/42.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/43.jpg b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/43.jpg new file mode 100644 index 0000000000000000000000000000000000000000..54af9c93c6c593ddec1064b7d199d6fcc37407e4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/test/1.abnormal/43.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..95c01596944676c68618a53d87820533442f0a4c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b68bb7ec1edcc65619c1b79bbb9e85218f8d85db Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6b143092753e7cb8bbbaa0e6d67ae76316655f00 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0814f4490fee5bc9def3fcd8c3d6cf6d515215d0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4e5bfc6688cfdef129c6cf142bf6f349aa1cbf2f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c08a58a8e34bf5223900896c1f709a703674d468 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..22fc478f39fcdb831168a3584d54c1a0f3fd64ec Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..561876ceef8486769f37029f75529afe33d02029 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f0fda436c2c28c8ef8f446ff8cf6460ad197a538 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7982961ae49c5919f6f1df30c527963a069904e5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..00b3606140d2c545f1b32ff49b51c0e0c1d2af40 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/001_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8fb0d169be073b2ede367e13b39f005aba6b34f9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..db4f310452d8b1a45f85e50cf67f37abab871ac1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..04ecf04e8edeb5616ae8d90e1150f7b80bee5c39 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8aca55cd29442a36b75617a2182e8d1050dba033 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a34688fd7b5ce68a4ee96ec2da88d6677553e924 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7badddf7c2b4e23b0f202d7f8dc56a49591602c6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..00a07faaa6e981f170ec70197d8ef4044aa35265 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dd053747517120814db03225e38c0e2e1e4a6313 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..261c06969035edcb7fb3b297093a6709a4b679ea Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ba98f78542dbd5b280e961bd481b159c490e2764 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/002_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b3ebc0437d20d2c7ccce2f9226cd4131a4da21d3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..069dca5875c7baee55b8ddcbf8a15aac3f867059 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f5249ce8179a31bddf2a5be2d4e51f5412ef680a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..82b8173729a07daf9ed0a4af21581119770728ab Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..57ce652a90edf9031492748310748b4cb74e520a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8635116f269824b22be520f24c40e6bd939bd9ac Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..154c68211d83184574b93669c3657fd54da6e878 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bf8a5d09534875f20f2daabab4ded8b16a7fbdc9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7c7241b093d577a428700143688586b2bd8d3092 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..14b8b66dc6314f095987cc82ec7e7749034c77c0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/003_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..707bf9c0d278b6fb5074f2684fa5485b54294c6d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..22ffbd614c04c5f603918273e65e2aa58bacad76 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f2deb242933928435b20e1a2b5f0042c04b67f75 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..06fb29b3f7853ee346265497756422b3257a0ae6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ccd0246072402b7f8704a219a3060492580d10c4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a4c2541e4c343c49bd41a85d5d9d0b7a262b7098 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3feb46284896db4bb9e6ed60726da7f2177451b5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..51cc5110555b412faa2256c7c4458a22d1bb14c4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1617d3a4e5119e12a12442e2fb2ea14dd8ce3421 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a2392857b5cbd959031276e27cb2bed15e6cefa5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/004_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e4fd3f5efb077b64e628a20b0bd69ab2fe10fc32 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6faf40c6b45556ae86215ce1da73743ab9ecb552 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6a55a27c82be23ddec71adfd96a85e5a9d33f8cf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f55696a0a7e9c82de04c890f3883e675e5f8d229 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d993f91a34cf2dfd5352ed112bd43b3519af19fd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c226534ff2ba4ad486259b27b2d49af3ff5fbba1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..58f0777a1edeaf30c09277e1fef8a72d4b6d3801 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d1b682168ddb4d41730a71339632bc174732fe1f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..76de40074d1b2eb86837557db9f8c0e5f79946c0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e0f7f34e16e334253c28a98676268e81e9ca8064 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/005_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e0bdf9bc67c17cd725b03a289e10f406b0c2be5f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1c450c480f2efbc2d2cb6c3ce30be7b4e81bba25 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7dbc89a1ad83638dcf665407742c1fde673f317b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..03cffff5b6599f2fd9ded50f68ecb7893397f9af Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..64779c13ec00acdeb4f51f38cf579729cf300bf3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2cd6bf281438f6e00eff091d8507cea59e05d3d2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a8c3febec959b3fceffa1a89cd1225c4df0328ba Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aa884efb8b933f165b7cfd15a64cc4b58114e8b0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3c25c1b454c14454f3e8e7fb29a608b2a10e78b2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..262154a5585ed8c464e6e3d879905da509716cef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/006_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..01da457291d129ac2efaed2404b5765046b435d1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8f5564b2d74279246c551f3b3ffe975f21071d73 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9cb6fa3082568ba3aba33e50bf4122b903b90693 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..31b7ae17d3d154a4684dcfc8828844c305e3c6eb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2640ba5b36a6124d1609aa938dff1e7672c647b9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..165d7a89e3e858645aaafec828444cb7635fd6e8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..21a00c83d46463eb5c09dd1e32b087855d2cf636 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..71f74efa2bffdd061b94ac008973091725bc7de5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d42e90b152179b150f342871de77e40a19333284 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3f341ce55287417165e88c604391ad4081ce2feb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/007_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..22b8130dbb99e74dc31818a60a420d745bcbd7ae Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..21153228f1cf56d28bcd0d2f44044777050627bc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..688d443b2b8fdb3cc05e1d545de8978908d308b2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4b21a73d8233ff3a2dee1907c8cb2b39262ff01f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c22a9653030ff969b7f5160b7b9422b1656a46d2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c8111307212882b24939a037c9ab8cd55c1034d7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fcea2dbd9323fb31d10f04a361b220f72adfd9c2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1701d125befe35c3a1221cccdcb1553f2eff013 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4b00d9d285e8f73f1875963830dd18c0327e0026 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1a938d9a67e9d09d6d1212363e08c82122b24773 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/008_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..67fe426549fe72cd1b0fa49a0890bdb1469ef934 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..460c44ebc75c2c98749d019539639b5fd1db80e3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cf9962aa6ec695b923f5cbcfd93d3b43c14f443d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a579e7a34abba937f276ad8ce0831d9b7c75ccdc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aa31cca4bb1c8770de4c93482683b24e9a8a18e1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2189add104a6c13231ac5c020b5b4c22b2f8b6cc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..087b15ebabb665a0257b8f4758dc4b515019901c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1505adf426329118bdf979b4548df5e0bdeaf78e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c18dc09753832258d8ef585d0e570686b079b4b7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b0598be285d487a3215691540787f04965610a19 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/009_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f0cc8506e78ac5a3dffb274dc5941b5b9220ca99 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..96352d00ff876f5badb2c4107a87ce086651d1f6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5605d65296532b1c5f8a44fda6a48e11bf0eae7e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ee5c3a84fb66576744c7bc0b65dbfc540274c00c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..17dc893a59c3925b10af4bb8bbc5a01a541d91d2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c818adf7588a0c836a5eead92c90523007612b59 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b84c56928b44f7ecd052268c9eac3cb329b2e509 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2c249c4584b2288366681f142af1875117c1f5b9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..58170ece3e144add87af19233bd2f7851ddeabf7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9d73ed0156d5495e4fa562f07a62fbb662c977da Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/010_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..23c8c9cd8208737c5b2444c017645867d2e244ae Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..df3ff4a667d38d5d2bfd80a4860114b6f2f056c1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1c902d40ece482796e966288fdf9e54487e91d43 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ad56ce3913f80952fa65b1ec09166b0f51a9a960 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..67a01593d7303f9aff64ed3c2395dd6b5a577fcc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1e82592084f13cc6fbb7638b70350a2527dbee27 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..38570c776832ae8cd3995cbb5d0164f8d4ee0fe5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f7a34fa2c5826c094ddb53c9e80ffb8b766ba72 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/011_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..de0122579236b77d79acd7566f7b0dc005626b2e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..decb424d4f83a1b6cc3888339684ca789431cc2d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..953bb923afe4734f0d887795b668850e2b5b6eb7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fd3085445397d4f0e6668540fc4d0e41401354b2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9b3c34280612bffce9190b33e3cf82e9f7f6259d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5d12e8bca642705e257f40f88f632c2c37fb4480 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..baf3e3d94707ac56cc3494f43f0b15469746fba7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f10f6a145723659d3c9a7bc963b5d27122f4a7b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..15ddec3f3f0ac8ce5b3378b0095ccb9a443fcdb5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f2939fc70875552c5727866d5f6834e5586fe1dc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a75889ff7159a57fed55e9def96c2fbe41176d6f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..85e4e3263c8dd1029b94d147cda55ebfd8021465 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/012_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a450a0802e071cc7f5e2cf5042a8d482b4c0d0c4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..85a0d995eea55a9cb78798a4b1e7f81e25a1db65 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f35a944f3670887e7126b213d28b1e656ba9a182 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7790701a742a95d24dd63d00101b73f07a1253d1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b127aa78bb8aa7e040531112bf580a042a9d00ce Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ea345b6a037b7776cceafe593ee428285b1ceda9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3a05a054da94af0d1089554cac7d17cafa3d2c3c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9e709068720d26b9b264012ae4480a5c1b46f51b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/013_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7e170c1d165113c691efbd46845947ddfc60ddee Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..331eb57c4312c5a329aaef2aa1d3a55b1f62126a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c45fbc133ab38849d09022da754261e39736d506 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8a8f49b227af7dc05095adfa8df133de65cf340c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..46ebd3b4e7306073884af546b8e7039333af133a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b27bd0c89a3b9890e54a5e1c2b608a377230bded Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..649524b48cb86a14488f7261814884756bd80ff4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2aedc2a845e6da88512c8239e1c1db8296a3f3ad Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/014_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fcb16e8a16d5e92af43047479a3e2e154224072f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..14c01f34ae4b8234f96e0a07720b58f8da7dd89b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7bdf7826a0f592d7853accc187ff07dfcecd3adb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..86bdde71d8ced9205d8ddd9e97aefc8a5e12f42c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6a157756e53e25516eb37031016bc7271d6123eb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4a277a20077410f3edb7c71596fca2f00651c55c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8184495b11ca9808ed54090a99738aa058802a39 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d1f9b79b824769112b324e29a55f3a562bf8c445 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/015_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f8a1d63ebb090b710f5a4dd48a09ef060adb542 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4d25edf8be7fdf81150922d44760ac29824e8816 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8c2f77f3a8683d2cfa5f87d97242ff3b5e3ab601 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..73b7ca65ecd88d6edfe722c65a915200fc5694f0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/016_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/017_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/017_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bd53f058225f36be3920f279308ed0036d82b8e7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/017_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/017_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/017_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1c12451280424cbcd020940a4e7950321301cf2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/017_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/017_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/017_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7225b6b6b12bded21e654fbf91614321c692391e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/017_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/018_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/018_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9becd1dea2ea5b74eed45b88d06a6b7b6314723d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/018_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/018_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/018_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1f1b6978db06697c6f7d55725c6cc8a6763f058 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/018_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/018_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/018_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9e8fcd801d2179cc9471deeca8f7baaffeaf4e21 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/018_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..67ebfd56b97fb403a7b1a990399cb846fcb62ce2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_0.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_12\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_12\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..f42500ff60abbaa711052dc5e0e8af455c0ac882 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_12\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2943c77dd8f2059d8644457fa3f5db45b0c453ee Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b22785c10ee6c4bd82e7f082982077069c72f14e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/019_7.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_0\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_0\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..ea83b159aef3a06a9afc060050630ca0bebac1b1 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_0\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0fb474a6a0a9964e629a14413e782e0e5603d5b0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_1.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_10\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_10\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..b825009f0eed41a2bb6628c998fae175f83e2b69 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_10\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_11\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_11\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..397f44cdc5ddf1028659c802ee8803eb56a123c5 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_11\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_1\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_1\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..dbc5e26c13dd38cea904a2d19a63e6795459d6a2 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_1\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..51927f51c9dd4c8597c100aa1c180b3988f826e2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_2.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_2\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_2\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..64948133b686e52bdf6b7056757a89cd4d5243ba Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_2\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_3\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_3\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..d4c8d896c839e4111dccf755a6d938d623140e6d Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_3\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_4\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_4\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..64c8a4004041bea551695d455068690132a40fa0 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_4\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_5\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_5\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..ab7c4d0e99bf95b8641a555d38ed37baf7f43020 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_5\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..269fd62f64233b58a9127891bc88772f89db9c8c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_6.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_6\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_6\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..edfd73addff5c19610d499577b55bdb3bbf9d409 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_6\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_7\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_7\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..6255721459c5551ddbc1c1b95b78345b744a0557 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_7\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ef188ced501cec6770c9ec6030a08e0c32e2ea1a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_8.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_8\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_8\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..c32148699fcd468e3f11d1df6faa676f41503973 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_8\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c40dc4eb34d9582462d2aaf76c0103483cbd9556 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_9.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_9\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_9\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..1c3f465eecb1d813a33d0dbf1216f5a09130d6fb Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/020_9\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fcc238ca3ae23fa8481d4bcf5a83d7c3fd4bedcc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_0.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_0\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_0\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..63bf0e9880c36821ce3f0b0ce07e3ae6abdaf1d9 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_0\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1ed2c4fabc37048cec2561e1f8726aaa7f88f212 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_1.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_11\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_11\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..56ca4c434949369742d5ea6617683b810897ab7d Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_11\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_1\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_1\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..b61e4f96644bfceebf93f253ca39efd020c6a661 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_1\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_2\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_2\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..618c0a7f8bbce7787a93e3505c1539185468bf1a Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_2\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3c9174113ce288a3210c0740e86e8a523bbe0f0b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_3.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_3\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_3\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..34b8499987ecc85bde08c4118596cdd1e3f2b390 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_3\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_4\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_4\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..9169e0492beb00ae2e7746eee674537afc9df3fe Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_4\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_5\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_5\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..f1907301744eeed323876d667e8302dfdaf01306 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_5\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..84a6c499794900758e0703f497afa9dcd6c31447 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_6.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_6\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_6\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..c6bb32c2eec748d07f79a6c596feaebbfb7184f3 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_6\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_7\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_7\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..f5f868946604087a88606b25633be5053d4098d8 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_7\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_8\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_8\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..8228c8b27fa854ec5d7b151eab8e948bf2a85436 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_8\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f43f8fd074659e47e46b8768d16474643c3df6d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_9.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_9\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_9\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..fae44f5a59642523cd2f96656077b36f4f5af51b Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/021_9\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_0\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_0\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..d652262c20b1f7cacf697e38756c72d465338518 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_0\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..31ede2c07b695b52df43d8d34cf4b61c4805ec2d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_1.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_1\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_1\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..1ff97ddd94d77149e0aa521fdd95e70f3737fba5 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_1\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_2\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_2\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..ba1e569c1f2ff3605c0e8e18880c95cbc280cfd7 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_2\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..75a99ec869e583ece6b55df876101d3faf412cdb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_3.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_3\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_3\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..4b3bfb57d46aa907cb5c6af484527eddb1894f79 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_3\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..45b07a3afdc5ad589f69c1f9651aa324db8e6650 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_5.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_5\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_5\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..75466b1224734b0454cc2a6654180e90614baa89 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_5\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9c59cef6b8c9ed0349a1ba44a5b46f8c55b2a0d6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_6.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_6\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_6\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..eff9884ef7602d3146a74b17d362d0bb12eaad80 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_6\347\232\204\345\211\257\346\234\254.jpg" differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_7\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_7\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..f66403049314ad082e99f539c011573c8b7cf938 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_7\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3b1662c5f7644c0e929dfd008dbd18bc45acf94d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/022_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..669a357a0263cb3135199a68d3bc5c0b61d7bcd0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1616525cf5c9464a5c685ead395c4db918aae66f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1b18093a13ff7eb643f60deaeda80bef05bc4e16 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ffb5b3a9868c72519cb1bf100aabe1978fa85f94 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ed17b195d5fda2e2f80f565eea4c6f4954ee17c6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c8af95c469ca62919d71194fd47e1828766e492b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8e5b161915cf90040e64d1d6ffe0f785529b6240 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/023_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dfd10bf2dd5f1080a62d948af6d8e1d8fba0d567 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5a7ae80a60c1f76507da87a0626ca714aae4c57c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bc2524bb7eda8a39ba6e53611c85880c6ea22a75 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..06fdc7fbad052d5a67a4e34ceda5e1a1b059e87d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bfd7bf90fdcb213f5babe70ad81b210dd341e197 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2929d3ed7042375e90f0dd8eb1b7d016e730d67e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a0d773e4d0d86fa78dd21096f568472d369c11c7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..430d9368823ad097542608055d5e46f8ee340bba Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/024_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3b5dc868857b4bcb5630a0b6ad176115dcea29b1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..992fb20cae48a8e0a68c696e3580698b2ec1247e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..869c1e77837daf260c11052eb7c0711e983755c8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1688f44e27ed5493a96f646de1b075ca4481220 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c98f367cfd29c36fa3f02f66fcedbbe3bf075abc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9b6f2b82b385155c9ebbbfdb7388067b3abbfa2b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8e9446bd62ba0ca71656bc8c6a6d0a8174e2ca94 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6a2a53f6fa24a8a3d89bdd2d87e0f8e229d5d7ce Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/025_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..50d671d86b04b9c682da7c23606236beeec7e372 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c2d7f03fb83ddccd445f9a1f85eaa840b02b4ed2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d02eace410e1e98f84abba899ade5bbe757d7abb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3db145b84c7ca9c169d8fc9706f9ab8da287ea3a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..096909503afaa32f62f09c4e39323f07eac3c641 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..be7050809eff75a039b74c6800be930cd431f6ca Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..13193e1be8b8d039563df60a0b9ba9261fe9885c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7161d1fda7d0f1d170a11e15ab6bfdda29435dcc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9584b916c9d22abcc86fcab4d4cee4f12ea4d304 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/026_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..75acf63a5ef286fb6a73c49d06ca090131b633c3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a7b557b955c190125e62f12a84cf1564323ad4a6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b645c783d29a52632bf5e2db2361879a39c13dcc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..28cc20c3515d10bf69b1c239e62846db5cb942bd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a5f56e02dff132d8378964c99062a771f31c87c9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5a0c55a6cf1c810eecfd2d23107593580bb9d2bd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..57ec84b52b308f8cf53b95cfca585301ad324f5b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4a55679014e33eadf56b1c966d748459b4842b2b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6efe27159f841434d77f0157708e1302395f52eb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fd744fd01b43e1e7f4935359c0e48e9981c14749 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f399597ae816d76ffde1ac05ce4ac81efa7313d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ffdf60f7ed3eac8d30a9432328b69056d31b52f5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/027_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..83f5c0ce9016928c4db9b317dccd655eb68ef2eb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3dd388b39672cc3dbeb92b037f1c6d70aeea786a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ed68cd3cc40c29d370da9e3d5a72f153bf17ab3c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..23b4676251816be67e9cabaa838d219e68ef7a35 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c485e5b196d3a453c9f6bc803469b0c127ed92eb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3f2763d44760e8fa3caefb3ad0182408f816cbcb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dbb9f4399ea49c4bd0433c5159031af202212775 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_3.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_3\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_3\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..cc9f7412fbc828a19c09e9ca44fcb6d6f3e25765 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_3\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..998c52bf777184bcf8d6cdee409ae9eec7a9fc33 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_4.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_4\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_4\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..fde1a24b36087d97566d90e2df3b205ea7110ec0 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_4\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..549469e4cdf9bd697d23d46ac77820348337bc34 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_5.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_5\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_5\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..7d23c4c0448afd4ff155aff2b3549203a3ce5bf4 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_5\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8a6b91cb52307b400c92d8e9ebe221f1c65c608e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_6.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_6\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_6\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..2b67c4b4d6bd3aa13bbb6fb3041be27b7c34203b Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_6\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..16541bb6ed0ea564471075d52fed92fed1b978ec Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..504f6aa8a6077c486e55401cfec86535f49c014f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d00d859cab1aade1df8f9713f7b87a5d800debb1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/028_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..31dd8ea8f756b6fc57933fe260abf083d0b11401 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..773164cb0576468bd6b7122cf7104b07064234b9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..03b5cafd83f12bafa79a4ad61646495c6f12bd72 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5ce58ce75a8b8f7f256dc1d24fa4f2d957b88de7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2b168938a1f8ab0bc6baf03cda207e9d456181fa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1daadd6173e0bf10845395e0f1caf0b453368c2f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3fd55215ba0edcc51fe0dc785f35ebfecb63d12a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7c01da3ad76cdb8fb88c3214f5acc23c9366cbc2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..efc86458ed9a57ec9093b653a476e2de435ae0f9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f2b0a52072823afe76997028445453e44bdc99f9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2d1985de7297c462b919a6837eb81442286b9858 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/029_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..46243d351c7d3b796eaf9eec0be217bf68da8928 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b36400718de808db9045a2c4c895b1709c5557ac Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bd4ac6cd02b42ffd5079525a75565b414c114145 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5f27e90f58ba397407ccd4f5b374ad1a18be4a8e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..93d163bad1fcb199a461ca5f29f3b9f838ea9aae Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..862d38b6e376d959eb9f0aad8f836b8bc7cc12d0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a4046f0061a368ecd06660e98cc98acc7d329e9c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6443060af8d87776286c6a3f7e122ac404b93030 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..095dc2cf5ca9942f38aa7049d2911d50d5be96a8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..264fd83fe55575ce5fbe9e9708d0ef955980a700 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..11e9f4e1e06ce1d62e3766f851be511d413b998d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/030_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1a2d4f5e905ec4f39b6c86443fc3efc5bf37a609 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f6ef531164c6cd7af5d01c493cd24562bcc09f4e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6f9285803ceff761dff46b3b406ebe69f41143d3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6fa73f2d6f543fe9bde0429dfbd88e26a7de032a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_11.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_11\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_11\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..abab12dc35a935b857a0553707e93f349a84556c Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_11\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4c8bd36484dfd4af2e79e3cf23a369e054e75e5b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_12.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_12\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_12\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..c35527cca81444ed0eaf8617ce97f03b9296e0fc Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_12\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7d04d692b319a457acda16dc908703e23ce3aace Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1702c263977fe244f0a288e42b7d8fe577da568b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d280d0b04b7e9394fadd319aff2055c51e3a9621 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8e09ae8de0f43ed27cf2c3a549e35a19e3b55084 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8a830054fa131234a34e04a7f58b3042e949b5b6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b7c5210f324384025fe5b6e67e9c3e8787dd3feb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cc63ea3414a6a1788ef8521e79058794cd39bce3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/031_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..21dbaeeaff76ed2e9783979bbe112e90466d163c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_0.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_0\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_0\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..2ba07ce1f80098264a33c4e62a486a24bead559c Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_0\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7ffdbc1ebcb0ae5eef37d1274448229848f56fda Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eaae21324262964e316fa116e241ef59bf72bbe6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..26f19c95872104d62c6496583f40de6e54a3e339 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_11.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_1\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_1\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..366329247edffd7fdb2e18f37ae1b0d2db3e60c0 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_1\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..970afd1cde6220c37881f057878ce92067793008 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_2.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_2\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_2\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..870392b284e345b55a8fdda73340cdc827644286 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_2\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f27df9fa9daae25df4510b42b48425f96315435 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8d13938b3b6d3e6e1679908605f940c49ede5f16 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..79305493b83eab754e2fa878583cf608ad886f9c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..97accca35dbd93df4456bcff6195ff2c891c2f15 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e4dc1289b72cb74468686b8e3093b225a32c5322 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..abf63565be235a8b4c7c5847aa12fafa334d25e4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/032_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..252a32cf745b50bcfd6a9e81ba69819ec5b3d9d3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..882417b623d065b37cf8603218ecdf25bd41c7d6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b72d43b9f2f2be853c4bdd70107bb3b85398bacc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_11.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_11\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_11\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..3d298ec3902bd1253a175f65a9183a78db14e89d Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_11\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aed9c018bf09d629d1c250407eaad7ebd2fd3abb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4b0abfd2e6f689b3c4ff51505bca116ee3f84702 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_3.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_3\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_3\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..d2f6cbd9225d22504d586f172107ed12130b9dcb Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_3\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..be101512a14955a8f4b800a14a5ed5801a781747 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_4.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_4\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_4\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..a46d79ac4508bf7e05014c550e85ad35c7f8fcbd Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_4\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cc36ce804ad52100cbca8aea9e0e2c034b9d2150 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_5.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_5\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_5\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..80b6a2c42996c012a630435236d37fe912613a9f Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_5\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1fd6e523a7f855db182b4721619468682c6865d1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_6.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_6\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_6\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..5435bd3fe81feb214d2cd330586048af341efee2 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_6\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0aa35cc67108b84419e6b6b92fe2ef4ee7f55e8a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7acfe5b0bc62d73592d513ec064aca5688f7da06 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..09a47f4ce1a39fff90207879cc799ab1bb59df93 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/033_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2ee62c6971e1b2a8bd3ea6ae1129cb9aa426f078 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f2e11bb6d5e36692c5b4307919ddf8c11dac8d40 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4e3ab3123e9f5d2dd3c5dc935b3c4685b08b029d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_2.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_2\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_2\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..f12f96266bea9bb7d0692d0b3960137539ecfc3f Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_2\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..644e1ad20b4e872533d11b06da01ef0975572551 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..06be97fdcc36c82cfe4601bfeb40f6e771c493d6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_4.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_4\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_4\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..60c4aaec8832e6d98d498dbf4b5a31ee94dfdb8b Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_4\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b3f7ace472252da007c566e73e5e062580b7d127 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8ea7904a5a6a86bdaf3804d59f62ba83f5f2d1f5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_6.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_7\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_7\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..4533a9752910cb64c33dc93dbaec1e01678fb2c9 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_7\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fdca8864aeb18cd50018c978bf12bf073dac2ba4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..843705feb55fa7ac5b41a19afbd710a582bf1eb2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/034_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a11310a9921b2db73326227c824686102dabe4a5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..32bbafb2e59f81fdf5d5478cdee11221e3c6b99a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d3f1ab4c875565b44813cfe8dcc2d4eaed3ef9be Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d1215a26fe2a61141013182eeac5c505d0ed0300 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..befbd4782ebcf5571fbd7662e1b1a7446e8bbeb2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fcc51d6b3ecc726a9c33e2890c2fb4aa15f42640 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..23d73837083c534c0fa2568947ce00f173ea5325 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7020ce281c3d26516e96263577850a51121f3deb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..253a3be42df1cdf8c29371d951a3be97b1b19377 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..22c811a503c7be5bb9ff848b1de0b075a3a0e298 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e956930fee4f5c2df72a6fb4e566fabeb24436cc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/035_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c9570f1dfe987b8f8e4adff312381f227edea33b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..059ce7261422ceb126a1bb00490fbf86ffd13422 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2cc344e52b89f2f06238fd8353f1006a1347df29 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fbd29dd501ac8e6b07850c0ac3f382a6a83a6ee9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d08c0a2349f6826fbc245e6a8ad25f66184e283f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..463fd8feb78d6e517a29d1d8ccac0d19d5845c1e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_3.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_3\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_3\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..93141cb3ee730cee518f4b1976b709c57e7260ca Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_3\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1dc9f6ee45fd5805dfaf9f70cf3ebfd73abdabe Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..93d622fde5d59f3ef5948905a29fe25d4bbcd775 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_5.jpg differ diff --git "a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_5\347\232\204\345\211\257\346\234\254.jpg" "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_5\347\232\204\345\211\257\346\234\254.jpg" new file mode 100644 index 0000000000000000000000000000000000000000..375ea42cf3dc06e667df7431ccfbba94025a3241 Binary files /dev/null and "b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_5\347\232\204\345\211\257\346\234\254.jpg" differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..135aa5961d27f79b04e107d92d6dfce3428dc4e8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..668ca3442725b5b71dbcdc99d4e4875e568f787c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..82b23fc66e14288930436fe74eb88f2532a8940b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5f4a8fa54cea2ae2aa9416c2263fdbf403ef7ce0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/036_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9b73a0cf64069ad6426f797fa2604ae05fee893c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1bba397c003c8e0c0d61332c2e11172952bb4bee Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1fdaf52dc396f324d1e5822745d7361b917faa0e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fe5bffb76df48d744dd740de6af30225d340d199 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3e31dd29357e44d80b70796e59ba3d8f5fae8a2c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bc56c8c7f3e2a0846f2e3069b4231ca06aa378ef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e132ef294bba60af94bb3a51a9174cbdff8f430c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a909196127c1dfa4f14d3cc4fd30534db6445c03 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2b64964caa64978fc0da5fe0052d4e5a6a7ea735 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6f3e712bde140fb4390eebbd6b55263239657dcf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..52ba34471933c2683da1f53baba839f1fdf05735 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..491b555fc1c9f9a38ec2b8940752f71da719d2ef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/037_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7aa61a5100de0737ae29d0b3828ca58fa1a38ff0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4615d60dc524ebe4ed691bf76b950aeb3b6a588c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9b50bc8043312223ac95193e1c8300f32f7fe162 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..38de13962e41f05e7d8abb25b5173ef40b01da35 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/038_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a2426ed24faa65614d43d1bff9a0710b672bec82 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0705f511775c91e83acfffc7e13d82bab547941d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..260c649c510e21bcc185ed035bb5d55eb72a046a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..960c55c267bd8b115a7dd04795662200b7f39893 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..57dec9cb4612de147014c9a7ddf1e76f8d0316b4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/039_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..179cfdf8bd8129fcec58b016e9fda5913edabe69 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cc748e8c2747f0bd474e75f059e802196ee70b08 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ba079b564095a9ad6a126dda9a5ee457c9f35aca Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2da9d864cc143e8eb11e71c1253daaca218e12e0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..21b3de8a960083d7065835fce54976a5dba8a593 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f04a64007779339a26ede95f6b5f3a50c787783 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/040_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ac7a7f233ff823ac4412a901781352403e1fccd6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4a8203ea8a02affb33505ea71ed91dd647730298 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2f11ca9cd3649968d19165e427348a6ea9e491b0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7457633c67e7c0e6df0b6e3f3364df03b8dedb00 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..93be0d4df74c9d5a9c3e7e2778bf54a505341ea3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5ffec7238e65cd6abdf8da3618e64fb97d9ed719 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/041_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c2914c8dc7251c65ea220a2e2b1a457f7431ea0e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8148ab81140fa64fa1874cc8b588393e4803f034 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ce8f6758942153b28422ba44ecd107db289f1399 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..951222660a4c3cce8575da02812fa9f85cff0ebe Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..efcbe01c7a7fd8ed76856df7b29bcd61f730b0dd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1455033cd79db662736f8927c9e751944f3adac1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..181a048becbd4e81f0ac664454d5a86be03645cc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4743a2ee5aaf16606245816541ace2ae3d5561bd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/042_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..954ca78e45413f8eb6fa4d58c3a82b11ba0f8805 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3f7d075a747d1042cdae9737d0e9d9aa00bdec92 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b89878ab0a78d9bcb5a84265aa5cc9a80301497b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6158ec1a601e6a19ec98bdc938f9619f3fa8ed91 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0390b9c851bf21aa42856aa1001e54da2d85e777 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..96cde66cd9189eaa5e8d64a1ba17770de54a7ee4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e8ddabd196b43ed572c1af63b21d761771ca6d8e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eb51a2d7273eab98d1f9b092cc552c77cc1c5d67 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/043_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f7d3c56c6c0f5ceef9562dceed0dd52f580acd80 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..56d15ca9121caf201a8d7b25a501f92d8d0fb50b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..22b1913dc1686106d915b86d353500922a3d614d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5ead564fadadd73083392be3779495f56a334660 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ea464b7d873faf5ce099933205f5f51c7ab3ab35 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5ce574ca7c70d6fcd6cfd0c0f2cdb28b1668e2b5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fb82d062e642cc6fb788194e579d6bc00cec8a71 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..343238108c41111320f4b8a2d234fb5d090434fb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..365b2403aa52eaff9def1ce82e9776e2dd8cef03 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/044_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..22ce41a9cb3555b7a0f87492e5af775938b7d79e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..24d83ee24d6df010cc4fbad87610c16bfbb9dca3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..643ae2b23b7f545eb6bd9f8ba7d96f4bddc46540 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c44955407532a0e3a57811de66bcbf26e87c30cc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0b140153ef39589ee3b6a906d48cb6eff1a5b68c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..486383f9b761192692d07fd17203a77839f67083 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..09be2ee974d51376104d75f619355261d5f1e9ae Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..db474e13cae82ab332621018228cb0b1e8bf5d3a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/045_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ac217b1a5dedf720dca1cb1b9beebe31c827a35a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0724f5cf5341ba50f9fe5005ed6c15438fe2c101 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..757d9576a2ca97f74d179f3c26924d0d872bf9fe Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..45c9422a4af35a3f0f5036fc0b4e84e2e1ce5d6b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f6837c168ef8b75cf2e22c82744e3b90dda5d246 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6bbc4891c1372e5a86e493c49e6dc5e06d80c11a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..85b6a5b222d7c8d645143604f7ed192fe164c55e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/046_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0ba257deb100efecdf144c0e79ffa59efab529c7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7ecb40747cb4f5c37982a7b96b843367ff8c5b2d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7b29a816f9cbda04c9b419396d94d5f2cc679e81 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f9aa86752bc85fcd75fde0917b635e5de8f34d4e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ee04bcffaf461b482ea9cf751e5814d9ec0bf590 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3fb4e61aee677cb59e62c16b9e0869d244be6f00 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4cdfb4ccd075b4d7c4871c58ed96e93f0620ed39 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/047_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c500cbee55e695e0f494bbdd8b99a708e9e11844 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4343ebd86b750cc00600b2515a1964b86b272997 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..37b17ec712a6c0709db7c7184949ccbae5bb8b4c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..abee1b3bf70504f91de84168a1c2beea91fe4a67 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..14db26df951e184922d78eec78dc378aabf877cc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5cd87b1f3a2db17172213a2018eeb8f5cdf5bb7d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..57291b9045670204ca2339511e6f00e6e4fad551 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/048_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..069e7ffa0c1a843c55f076eb8fe84e11a262196a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..52bb2c35091f69e71a28ba426ded2262d9ee4bec Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9ba5797f7148f55748da69eb47be137253b75354 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0b140c4e9804a180886c120a04ced7bf7ebd29b0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..99583f8e1f51b69ebc08ec39eddc4d6cf2f8a825 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b59c070b035bf2446eafccfacfd8c6c48887946f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..146bd86774c3c7b2f9103ac1398d5ea213ea70d5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/049_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8a29871c4ca789cf593ba56ee14368a4a055ade8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0c0821676d904afd217074057f186b3b7aa61be8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..59def79bc7e62716cdd631bc8b8b31f080ea0a11 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4f817a8745e4554bcb1c26691391365f09614478 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4a9974682c101cb2b8b365ad4cde45b1d96e1546 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0e3fa753b2d68cd24bb660829d1b342c64d1ee1d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6946bd31d673d3535327546ccddf9b2058e28a77 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e314b3c4ab9949e7f36e3e727e0725385321bbff Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a5582552dc5a1d8f311375c0262c2b6b100a08a3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7af09932cca146f6ce889e26d775fe7802c8292f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4ba4de8c70e2b39872f369a8888dd9da8dd7ec68 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ab4a979e5481cf41db67478c5cf7fe9386c242de Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/050_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fc4735c7f5f26506241e653ca7a80d4f957fc757 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..573e6e3ef4c25e557a20a17c386d4432ba9c2feb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f6946f2225ad9dbd813c5314be6d824f748bbd87 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6171b05eb09e4b6fb82575def491f2055332f782 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2c7c35ba98044870d51453bb9ee2b5bfeef27bc5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..58e2f693d4ad11e4fa5bffc3011f2a80c2405893 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..26cc1c73572fe1a35d2028514c6fdd7834509eba Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7b5862384d6dcbc947bcaa0ae67148009939b5e4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bf04678304072213d2bf07bfddf06a053fa8f724 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9e3e612394f51240928125e204c36e5a9366f05b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5c108a851cda6d77ea609b56444ee05b36149faa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6a407d7519f41ad455c1dd81c11eb8126e471632 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/051_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8efc1b80d8977cc12acc6b2094de2fa9f426729d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e75c9150e7194a06f065d12fe40431f0dc2c8f89 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e0d5ce86f66bbabf5b2f1ff0e828a849fe730f87 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5aa80a94d6d6ac7608984b7a69107f3370e76d0e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c5f7cbeaa7db382ec498c58c0383a2556d34a051 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..da44dbfce2db35a3ee9c4a55215546adae4db59a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1e21f59d7784b20198137feb34eef945485a1442 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c1fbbc5f302745ef760e00b9bef78619ba1ae5fa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c0e2d0e9c5a4df8994536fea51a9c90248662791 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9ce75779bb55276df9c61bbde0898db271a715f4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4e2a3e6c772d6549d445332f6068bcaa8b337c45 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/052_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ce1a1026bec340252da9a1f58a2d255b7658fec5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fef4b2bac093b65ca469ad03882ec87a42c3fc34 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6d8dc12115d1a729dec2b08969a0686e25e0f79a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ee5f32938e1492805d50bedfaf4f3bc5a21e23e6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f3fc95218df571435c03d208db4510ed7e051b05 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..486df42f8f652644077578e7c3c9b2f7dac31ce6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..35fa2b1cd4bf6a3984a788e014a58a18a81526df Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..13d143e60c7de6aa52aeb967dbce0a91523cc833 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4f6141751bfd4fc228a3a5f3666656d7643a8788 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..45d45eb4e4d87d12568df07ffce69251d39448ac Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7e1b7a2982db382277002f1d7ef6a6ee9bdcc602 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..10f6ba9d81ec0db4b82cac40bf992834b16374b7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/053_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0e1b129cc19ea2c7ccf6aebb4548f35757e8ac99 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e3a2e836e622a3ab73c57af04060e71b9150b4df Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..29b8afd13c95751857c439a98da6584674c8e636 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8d4a6c3656c9f1eae00d4885463469048cbbe561 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8295a06ebed5c475164a95b2d6d713778ba9aa80 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f6cc2b0a3e83ddedb12657e37c1469102bc3a5ca Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8cd0dbb0fc0918104b30ab7e7517b854f543bba2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..287397ac3bd21a169469d8ab1aa6626a0c23e325 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..63c948e394675734ff680d501cbc9f28367cc3da Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f02f07fec082b33207bd51bfabe3c0e5131aa58a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c18c6a821df78b7301efd73de6556f6ed57eb3ce Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d1e734d0c29a393d2c03cec2b257a4d0e6c8926c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/054_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..073cf07d319c245e5af401af1f109ae50ee5cb31 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dacce36a52dd6891a5035ff7faf2c29ebb135b6a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..981fdfe5572e0634c8ad5d652447f6d52e8b7c3b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8e7dd8ed508724ff1f01708759d514e1808fc141 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..88bc0bbb584bbb013a3baee53a432eb4de86dc5e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d594a95d42d6c260ce878c871596047116d9a42e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a6e1b4d40763b62881da5514a10b2085ddadae1b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..85577ccec3998175f330d2fd28c918bc39df1452 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ad12242a35dd3db81ec34ec47188cdf27f177064 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fc1009f4d7f7c3a03b314a1417c555fd83dee840 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2682e23421f3524d9001b36feba9737080dc98df Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/055_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6b231a428ef616f6d6876abb651f9e1877257d5a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..772ba7fadd067f5c35bbb4e2fff6289d7eaaf5f0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a03e6a3960a297887b39804f5086bb09ca8845a1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e18d9344eb508f6c4fe5c5b28bf63eb61e6c516a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..70f293be14f64aa861a51f15e2ca00d9a5cc0aee Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..307979c9dec0886a9be3b923e2c13c4f16cf7ab7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5fee8acb7fbc16101ab4122c13c2f285ff462b1d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..575241318363435ed65698b9a322ab06cdfae11f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..948417e0811e965684226e755be61fa499454c36 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0a9586c511a097605080ab408b5980ad35fabdd7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d69d1a78deaf4d60527a3bd5154c8fabaf4591cb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..19067b923612f64115a93c6452524726b8c4ce98 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/056_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..317bfe5660856ac1123437379649b4cf5e02a203 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7cb17585d4691d763a9afeea959d3d49755e1acf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7b3e4c1fa1904722361af840c22ec454ac85e44d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..68d77593c55aa56a05965d89fe24ab89180a1888 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4be700e574c442f8e51f552c77c2cdc63e331aef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..958d9614dff65097375d452f368b43588195c45d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..caf49b85118bbc779cc3f59e2d7d42000acd0e0f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c494f563fc3bd828714fd2b129adcada500cbe91 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7c645dce3bcc025fecfa8ffda13decbe1abeb690 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..70b0337e75ed124ba198f8f5b0a1d60b5ad0d6c8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..00940d2c7cac81120ed094f97b75988de2e7eea1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/057_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dded5cbf1cf122cc494ef63d8619121c08c275a3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b6b15f080585a127444d75cf0e0c97bf0986a020 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2f2d4944d051842aec69da82e5ee36706ae25e3b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..01fb487198df188a9f36e13961c98fcba0046a9e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5f091823fc5497278823850f08242be1fd0911a2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dab205bf4749b68babc84f31d0b2a3fae3ee24b1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7e4407de9d22b72e2546e1480942b66ea232480b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f7f088f0b7e2b22673ebdfde5b99e6308e781be7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..27756b143b1cbe1d9677749a9e66e91496a19e62 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..759992b7e8ebe955abe23d2dc69db1e4a33868f5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7f54dc1670f4df9bcd4b6cc755611fea7375f0b8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/058_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..17465049e2ed5c45cd4376652d01c2fa9d7ecaa9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e819f3069aebe7d95f53178fc2cbff7f9bf7395a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..96d7d663963bd6ec89e378ffcadf9725119bb35d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5e23fc3eaecb8fe2dbd78758024160ae0a9a09ec Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8fac398c03a419981ff7531e7985e768553c716d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ac6d0edd08b974e3a248f353e589bc09436b9fd3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6889f924a426c0bc1c0c176f6e47e2af63299608 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..722f9f5e7848657dafd5e2989470eaa567834f06 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..92affdad7c667ce98bc91a1889297a0cc045467c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6cfd0f7e145cf659e44ad979156a5afca7f11e5e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/059_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5efcb0f03b30d3a5f04ffd0366aa7272fd62d4f5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..31e478d2a27a02639f55060450657c6b044aaca8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..88ed68e6d65948b0a9d2a75cf0a7faca10aaa93c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a34e0daff37025927d53893e5fabc53cce23d2cd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..052a131e51da37f92ea8df7c611edcfd36f6bb0c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6e45d42297d0b5cc0c862c46715d190a25d7cc78 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5431eb3fd9d4ce201d956595322e4fdcce9a4d69 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3057854bc0afe34bdbc8c97c299b7499d265fa55 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dfb922a1d864644049f4aca1143e74e0f9c1ed21 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d62a99c35139d79b9ddcb7ee7bcd5b4cb9ac8f3c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..529b588df365f136d2c6449c599a6f723efeca09 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/060_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d19a529f6167e941ed8ea6831d0c5c0ec3c0724c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5ef57b0aa3eeed60e73b1813fa321f34261efb8b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..64a21cf6a7ac95a713e7636410ef411a4bb816df Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fc7c0e98275fce8e62a9f8ad569ecc1f9a4f9004 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7b518969aa011e49055c1f6f36d1030061550434 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ae9a6ac60d285d8144e23d067b50297f3215486d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5d33acd72561bbac590b4be776df8a64763702ab Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ae839cf10b57f5e32c55d6010a4c5a682c718753 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8f55c49ae4b353df6206cf47b3767765f1dbefec Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8150a3b9b787066d6408a2f996d371aecfcd6feb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c39611fa00de4cbd9c5b8cd1595c1f7b91bf43ff Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aaafac4b01093e4fb656dcbb2d7b9ab1d70bcad5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/061_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f1ef1d0d34d71178bfd37fdb8d55e6f6aa9b1983 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bc3b64a951eeb5a6cae32a117b06564a7c7d995c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7100836f7f4dfc6fb223934f5febf83111cd37c9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_11.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_11.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4d7d71610db2b566614a274cf1e3f358782d51ef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_11.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_12.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_12.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0ce06cd3bcb11ba4878194d9c48f886913056073 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_12.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cc0e0cc3447ee619ca0dac9f10cf2aa70196126b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..85c12945f62b2be96697a6a24ebc15aac7dfaddc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..960eea8ffb61b725acbbd74bebcf74c6ff64c2c1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a484a3eb2e2a40aba748d1f27479eaadd97b63cb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..54f458fd1d83722cfca7b569e1d8e42b94012855 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8645b5f2fd089e9a8197e214952703f25d5e6296 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..393836b33c76689d1faafb357af251586db561a0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/062_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5da2db94bde4be168921776676c8ff869786dc83 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cec98e60eb9ecd6170b25ce0bc3b8dc36e780eb8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..721b4dbef4e2f4be0f06902c78e7df933dc95074 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ba472fadaa0a25b8a7f6917c26bd84823197ec6c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..217a19f2c5042924452492ee620418a466628058 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/063_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e97038e31b24122ffdd889876dd9a38987b9cbc2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f740cccaa5372ed702102bd07f262a705eee0319 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f17140d1ab1d470b0607a47e5ea00a397e6c36b5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8ed6f1c50df207e23a2d02b1b868663d6299b01a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e8d947bde87a96ec73e70539ddb54a151bce0cbc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..40febb39c9249daa863b12d69f83976870645eb9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/064_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/065_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/065_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..710605a98706494b2067e04c109040c687dd1868 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/065_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/065_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/065_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5ddcd9e5e79b28aa7d6fe999f624821fe9f1c62d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/065_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/066_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/066_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..012321fb4c531c7222f21f1f3a4881f71470461d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/066_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/066_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/066_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5dd61d1e1571b4a6671a1dddb5919287ce5f007c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/066_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/066_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/066_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..76071243c030bdbdfe64a083f49a609260efa721 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/066_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d94c7ab3ba186239fe436b51cadedc672a39143c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d7ed9662dffdc12fe9f16f2376721fe158267cf8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4df044b19d52af30c81d33760f68fcd57e5a0197 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cd2f22f27e042f9de045e1547e2b6fa7d52509c2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..edb4fce0f48acbfa77c5420abd5de66c038e5b0a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4b93485a8cf7f654f98a878347da24ffa3d33939 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..25fc69fdb0049de048e40acba60ca1ca4dd1fbf7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0f7af4af603e0d0219b439038cc216c32b324f40 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..80eea20627d864eddf3765d30b6835c9a5caf03c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c70fe960068ed7a46be97e416438c5782aebd4ea Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0f5ac843f3ef26d78b6a895c65bc866f97a110e3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/067_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69823398e130a53b3c6c141a079a238ef5269633 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9c58ea088c1115780c741d8b3b8db0718b86973a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5fffcd75735ef392aef8c47ad8613cadc5816948 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0e6cad85adef3116c18643c5d3f432d617445c35 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8a37f9d2e50fd81a1c915da7edf2c6e1802e76b9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6a01684fb05c1dfaf2a3f67d190980076b4b3ab0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..29fa7d4a3897553372dd68d33caca8161893a1bf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..18e10d1dea09f8431112c172f183e196afe3b6bd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c119275c25824cb7a1386bb521fbbd89651a55c9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9dcf96c50ee2e45e4226ad5c7fd1fa6cdc9c169b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..89b1224be29e056817f07de83e6e0d10701b5a98 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/068_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..293ee80c822d3c686eeb032b4bf185b5503018a1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c165cfe2aacf1385068ff54408be358f26bf4fc1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0395bd8dea91906b88b383e2ce213d2ba32c8712 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eaebd4b46a3ee2f6fb67197196128c8f59c6fe3e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..99a8a1aca6506827fe683712a904033919d676c9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4a76bc4c4308cec35ee9fd0d33b7f40804d6ccfa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0a1bc858704a507eddde8a573ad390d2216c502a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a78cf7e0fe18e8122c4ac4969207144176c3b73b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..28adb9d7bc9ad57c39db7870732c47fb0c05791e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ff673740901d4ac9eea9d1912b8732e17aa4223c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d6ee7791128f0b71bd46a7794a997dee0b36e1d4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/069_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..54a2e0b4627fc7ac7da0f6096101ef5a993117ae Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..232b95a709664b320f032e465a96ed4a1471a108 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e32bb47f8ac2d8088ba408af5ce470df4f3f3c5d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e697b4eb3bd77fe525b7138bfe18a4167519a8bf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..088f9f2426c3d83c55951650dcc5ee7fff32a57e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..712ac26c128bdca51958e2429989bfb30aff71a2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..67e1eb588336327f11630f77e19c7b32b637ddb9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d701dd80ced2461fd0f9a737028ed3cc4cd38ee8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1fae23b651260ed03b1b5b7bd78312c052369cbb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ce2744f345a295e9f4216623041740cb71949d74 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..11fb2f589c8f6ab09286d20623fb78d39718753a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/070_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..170b447244a6b188a1a589100d395e47870fa908 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..53aa1a8ce50c3d903759121dd3e1f176f957114b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..839c5a8481df611d5cf5d7db2951c9fefaf07e93 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b78cfa36d8a72e6e30f09c946b667f513b183d17 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..73571691cc7a1f13b808eb322a0949709c62232b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..04eedda92c023448d5a3a1d2fbbde81a417b1887 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..58ffb9f9849f1768625ba63b3e8404bcbe6fe068 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3aff08c5be9f472f75f45fd3e59ff31136b0bc83 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fc0de14fcdccb5bda8998cafb8c7f5236c311a5c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..27f0215c902701c24b0a2d288f1690add04a9cdf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..377dac1cd061d3fbdf0a1dbc74a8de4cb58c946e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/071_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..72e08203dba9be913c95c245c3994c9e309a0ce4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d2dbc1fd6d5b34c186071d43d4731279c272ea2d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ed1bde10dbfcdfff41204428dee8d85d05646abf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5bf946761d4e918e4cd7913a6308c16f270c2fd5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..da4f104d2c6a0daaebc620efbe1bd828fdd3925b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e517d9aa4b4c4b82fd45c1d71b4980a5b4eb7e60 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..92f3877d996f69a91ccc9182e1f9ab7ea3809cc2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7ca0d5a82fd81c023098d33102dae6a02ff29f25 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a7ea25d1f98dcca312125f95ab0547c782f0d865 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0c8a29e4ed47f378fc0c8a106da711028113e2f2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..820856f6b93b598d64433f2dcfd1b6ab832ca6d0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/072_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1013a0eacda11d02a27ae66686c685631a80b1f4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fbe13f54f2f97ceb95050e8430b49c4d6a20d798 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cb831e992fd9d5ee60cb2ebadcc91e6716f701aa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cd15fc17187253c0cca1dfc2fa5933a24753d130 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e7ba42022ef80690cd815a88e6cf129308ac777a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1a65025ae4736d3a9744d0ae8897e46d0861e15f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..90eada61c5305dbf80b8693736b5d7c2d290666d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c83d5af2419e246113e9a1577a5b8d40bf0c27df Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0bb69fdcb8d735020f0307a3a6210136c89493c6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c343c9c334ccb197c4ab0593e1c7d0d075a6e76f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b19442c32e3f8b4dfb4017174a5e9758ab86f7e7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/073_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f7ad0b246ea3741717ee3d5d3f580b9453766d4b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f53e117ae8f839010f6c82633c58edfaa85a7dd3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aaf9f277f6e05aab02e94c9d66ab2174f74e38a6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ffb4a37047db6f47543025edb578418aa6e66642 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..64af351da741507dc45d3a6b47f91aeb51a8f9dd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a94336bb480de25d5296108304c8aed02bd15c60 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0e0433fa73bdaa10abe113940344cb05c0a2d796 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..693941c4693aebb4100ce188d9efc68f1e962f0b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1d647161dca7acf69267963f356f6392c943c59b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..304a1b04eae08f83c943ce409f170fc1167f1e81 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d73f46e358612ed2bad8e54b4ff88ccbc6dd5cc4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/074_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..444c532a30ada325c8c9f1e10b1b68d100d60c81 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..50ad6f413ad4be09aeb140d2f1cb23b0dfe147c2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8c9f7b61e8790482efe9722351b2811a541c7aac Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9106596a4dca553e894c8c5bd2ae632f653c1a85 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..10aa512778e9c78497aa638e71c5d74c1b97ff85 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..83aa05075e3b5eae2abbc3710c4a7c5bec16fa6d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1709164af5555250517a8c735f73431c9b04c504 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..14dd8ad78cdd516031df2beff2454ac8c0dd88b6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a717f06e1bb1ffeb7feccec3bb793e0f87f9237d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b5b41392281f1f5d724354efdb3438563c60021b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5ca54b52e585658b3ec9c86ea105dac75f8ff1cb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/075_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f84f00d1c2d92c8d64128a1603de3e608fc673ac Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..191bc177ef2ec398493b2bdec2c7f83fa203a4b2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..83e8db04053cb8d958b54dd692b5a6370ef7cbbd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5a50135263f64aa5600dc3f75439898bccd7615c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1f51dbd10fb73578b22d0346b3e287622b04f97f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fc28a71ecb8b6cf82165a50bec159ef007055d4a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..01ab1800786241518518e7d3b250ebcac1f9e811 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d2f497a45ed67ada8555f366a82b62f4317bdf8d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..be99e599e6d8153fb790e466fc1b415cfae47817 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ec0980f2b7f35027f52035d434fd5e3f0e445eb4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..78b9a2f86e0ec15f5afdd5e3a3d85e1f46f9ae08 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/076_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ecea3c280e8608bf43fa0deb7c86f08fbe1c4a61 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e7c8cc158816fc87c4d7b16d6dafb4e64a6a9234 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..949736fcbe679b13837c53cef02ba88fd6dc7d10 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..760a708a2e1d09645d0e727cff9b93df1a41ea8f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a5ea3578985dbbd7db7f6fd3235aafeec57438b5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..799190c500e85c73379e39f131988f0b0894436c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..500622d4bf949607b68e8943e21bdab50d984027 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..09b37177efe84a14e7fd9963a5c3fe048d939118 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b80a88ec87feb8a2b5c9ab37e59fe3f4ec2ae31c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..923822040e9452089ca476b02979adee4c7b4986 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4f46d2bdae94d295b95d2cc271a0c85865aea9d5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/077_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..13086a192758f1d97f8605062995aa7bbba9b001 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fe60a4c8acc54d600c7d215683211c945bc06e4b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b4f82786364f899f15959dd21cebd1cafa291d85 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1ff9009ae6ed30701f71ab65a6dcd5a59e2ecfa9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..66ede9ad87a04bcdf3578ae7e982dc7722c4edb6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e7529decd07762c07a214fc522cd8480335629f9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3671f7365b10ad3d116b0e56a7e8c2ea7c9e487f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7c6cbd63393f4415fed7843ea80937bd3e9b3c65 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6344c556a1ae061870db87c999f1f3b03365ae34 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..58232fce8f9c1f5e7b31d7ed1361ef8d406280c2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..87d988fc3df0112d2e0afd38c9c3ff71a47fd3c0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/078_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..62cb523a049a51ec9bb9f2ce0be780402fe415b3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ab386c5e40666ad709dfe420ab14178a1bf557c6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..487c6c6b15a7bff6bf4a599782fd5e15c597f0da Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a57c3591e67ca70cb0a03f3a2d5137f8a334c8df Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9b4300ed13ea9d1296bf9d4f413ff740a3fbef6a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..af39de64171188749c63b294a16962e8788a6db7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..760352cabd2fed6c4b01dd4520ac19a66d5820c6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..533c325036c36170eaf8cb8549b1fe0fbda2d44b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5c7a31c44ecc573ac8b380af1926c8ebef9c56e6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cff9487915d840cf4cda4f00a6de0bce7e51f481 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ad29636d9bc57470d146712b18e891859fde3a3b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/079_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6952a66157e3d4ad552cb8c58d688654aac4742d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7b785ce3c05a6b428756024a99b3a6bb3bd3bc42 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a9c5c666dccfd1f5810ad88c2e9a35fb66552cd7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a63f894036b6db9a53e1e4ed6bac04f5da506a73 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..246c495f8baf83c787059b085b6bdf4ef402d48a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..448f6207095f06ae60c16a2c9685cc0c540be9f1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e17c885a3d39e3bbca67fdfc17609c6ec86e1dd6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e7f0074e4fa613ba718536464a08a59f3194ec2d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fe1ba95764089897af436350123a1def1af27139 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e9aa9c1de7c9214f34cbfa8b7e632027ef6a6a73 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dc19f630a1cf389f2f8e2b94e5d87e10363f8a6b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/080_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..371c274ecf98f54b9e6984b812d2c24c47b9cc57 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8352d9451fd19456a0b697d879db0e1c9570341a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e47d8fa7ee696a974b4b30abf08f84f57f4c22d3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cc575f4efae97e30298c0f0272dc9977e55a20ca Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ef33ef2efcd15fe15935772411f861d480da071c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..923553cd787075652f0907be2803ebacb6073e91 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..67be125bd7cc9df26e07332cf7ff8e501a1f7668 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8269c590a3faea4249d2a79f0ff5e45517a422f2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..25fe22a30e9d02cc5a0f33c9d0fa0cb695d43f91 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bf7174c2f34866ac52ef7a45cc4130aafb608d3c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2c726c7157262b6400c277af1c19abf8dd90724d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/081_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dc76adfa4176142bd9721391d81ff369e4f636a8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..907b37a7d332f60301c9c94caec628ddc1b3dd4e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..131a90584d3b7cafe0fb45dbf69f0a2f3040a77d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8e90f459ab6edf0a898ea62d6529a3e5f05e6794 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3f0382701b5f0ecbe5941bd4733ca03ffcf193cc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..63f5b6dab28bd68c8cad5f402c20f0f0875555e0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..344813a3c152d571f127768ecccb30e91d336659 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e4aeadaea5f4fa737ae98a4a9afe2ea5a3c36e8c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..29ae4f2125a84547e8f73b7c974d0370a52831cb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..712c39fd38f1423a4366cc238498ca52aa98b203 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2570806e755b46a5fab1b9fffb1f3b6d6ec5f41e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/082_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d461bcb623556e5504be122ae6caa6ba2130ca9a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..667b79d5632baebd99f8988143eb0e1d8a2518a1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e1688cf5df9940e5416ede57197ec3f4fc867b24 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f7ff2159bcf137d9c144648475f4b11b4f2026e1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ec0ff2b6227fe5031d5407328d44607b1711d705 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ac3af7115b9917d256aedad2eed0c7f45c4ba419 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9e663cd9dd0079b3a84168c75cf0460cebc3b6df Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..369d0d1f2d39cc6685e6674f2b66aab48c828100 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..45d651938aafb7492be931e54e00573a558e65ca Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..680771ec05c713efe8a2291c2a1bdf5f949a5ec7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2442eb043450651acd1a3df10b13c3562abf1042 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/083_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7a7fa197c0c568f584465fbdf6ab19e4f83f60dd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f28f36e63392e0dcb27bbb26ab1412e6dee64e5d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..59abc70fc8d1a92af6abc7e57dfa8cafbf2222a3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e448fcf68d083f7336d9d761475a473ca2933e52 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..34ace21a41ab510cdf5fd47fa3d134ab3a11473c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..781e29779715becea7f9800b64818c57f0000c9c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e8615ad838aa16adcfe6a99b174710389cd4d669 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d7adc36b5c0ae98058ea09e41a667decbbe79df1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a7dbae45f78db0f544deda95f480364e3fd965c2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cb1f2eb680578bb4326634b16614a4f2e5d12016 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..20ec305c24eaa1cd52875be519b089721a24b243 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/084_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c3fd92cdebbae5f594e0564f24d43f37a7ea50c5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6659d7a70c93d698d2f5738d3dcd0325a4a57524 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5d3ff2dcf1d6ca28a5715ca56e3ac27068e66052 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0e43fe6435f4bc2e1b4f2329a66248f961be535e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fb2a2e6ab9e6efffa6fd90a5545da033682fc440 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d3fbcd628edbba9ca9e4cad3f1f40aaa8d91fc8e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b8bd37bf417573fa0292cfb80b2ed068f53e9b5b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..78f7619915978068bb073479ba1f8e33d5cad3c2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f811357c55e86eebc59ee459bd8e1ed2d7470618 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5414e56959eed9e1075feccb34cf194853b37c20 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6c40a120b8a8596a21ea86c299d16ac064c0b3ab Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/085_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..97b296244d0a8ffad3ad73a1848fb40605c43664 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3a72870270f05a45937098b556fc9b8fb27d51a1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d8f6ebcfb4b5caad3e5ad85c0f8f1bdeff63b843 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a36ce20242279898ce4a8afa506df7b28219d740 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ce6319231d4f508607033c602dc07e3b8c893013 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c7213abbdc1983f20c77471409413b66c48d03ed Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..42d74dc6a2bff040abdb8f5678f17355dddd5662 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fc0b271a28303c2c006156ff4ae833e857682057 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bfa6ba61fe13eacb9f9996ef3502a937f6f273bd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ef19bd9e7d6de42d32eed548fccce5f412c443d6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69b77fc92dcc792c8f703fa1fdb0bc0204c94151 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/086_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0b2ccbeb812d213882cf3a836c74a0b29c82c33d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a99587093ebffd7b339e3fa8999faf8c74843890 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e2e5ff503fa194fd9e63ed432b5ae92d6c77fef2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d2bcb56aa9c273833b9690e0b959a1372215aac1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f2c3ded70a3f41027630f4716b9668f27b98b92c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..180a5fcb3d57f6319b8bec5c68c31b024911f20f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3c5024fece00edc012e583a74633a34c94474935 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..834d4928226a46747c6b1dc8c268cf38542f81a1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b0ad90ca005210fec011fdaf13d2d183a2d05572 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..10aff9439b8c513407768386dd5b34ed27dd3670 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/087_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..22568dcb9b2cfa9b0271999c3674e10f67cb6550 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..63ae8caa25cfc35e304c80d15def9b77b0a290be Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..74433341507b704567ef2aee82f5703f30199998 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eb89d55b18fcec597ac027e66ae48057117734fa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7272e01f4e687ac271519ebcbaa00e42e0492e18 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..13ffde65186c256e2a480befaa0d6fc3233566aa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..30d16924c132ddce0da7cc9d9819a0940415f571 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..09f0c2099ded03ba3a253381fa4887c7d7161ecd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..edfdcf7fd29b49d43f004d43d7f018a25f00e3f4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..06d59fbdd68a7aedbd480448bdc87d1a34d51fb8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/088_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..75d6d0ac99731b3421165f3a480b412da4a5c36a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8c64a6f61bfbb245d37f9d2f8c3daf4f170c8215 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bf1100cb463b840f1a8324f74a8577dcf1df69b6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f83f5caca6916bd52f5eebe65b29d91fc2c78655 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5eadfa607e6953d99c0156211b1a023352f0dd1e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e097fef84cf4c559b5da3f059012f344a6b6ee41 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..300533742ae4491b9f0aad6f9f9faa5d41a3e26c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fc1bc8dc3eaacec0d44f3a740ddd143c88f88245 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cc22d37b6f5d77757019c17622344df335e0927d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b983f49b39a443e7c05d1cb10e700765e72953f4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/089_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b5d97a7b120883b2acf61cfc52cca5ac40f49187 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3ad5bc3b196e21b767e1bd55e0693750ba65e9d0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ede069d60aebe275af284bf9efd56359a4127509 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f45a40af758909fc5bcd0c2246081d3a2670539a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2a5d6151e8059136302c56616dd393216d9fff9b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8bffd3c31a47e2a4308d03903098ca3b596eb111 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0b5eac828d9eab2e5a19d19a5ce6c4564174aede Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..746c0d6d0dc82232bf338486177a94afd1da2db7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..edbd2f18b1fd9a7eaaa171424516eccf981f2c80 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7d4b7a6b3eb523ceab2045ede0f05d16709e070e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/090_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69796c3a54ee658250a9c99fa6ece4ee9d7205a5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b3fa493ae75c64752807bcdbf059082e82ef49e4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2dbfebbf0f55738af39560320363e3642eff5a37 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..35cb4960bc250e8ba4011dcc9b267fd3450d9a07 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3a7afa9366f32cc0a9650e67ac983b394a4161bf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7720f23a5723128aaa171b8c81b42653e393912f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..424d3533a31b12c68eba2c32d9887a2971142ce1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2940ae8ef3096b99135046c9f81b028105fe906f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aba7708f8b36db7460933cc0cea9714a7b7549cb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..274674e6a8d719142141921666f9cd63dabd300d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/091_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..99356a2287c3b69cf03c1dfd7f6b08cf920f3a81 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..723fb1d0aba2947a83c3095a98e8e2ff0438ae4b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7eb72356fab35117a9b04475b8417270f05202fb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bbb495a5ec0fa7653bdc5a1db6f770c9b55ca0c4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b7d0f1d34b54fc906ee1af95ca877eddef3d9e1a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bbfa090191e00a65e69378e9680e8ab61161f203 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ead5e7e60c4fa91d45a30531e45c0fd0be5de944 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..df8b132b300f1012b3254a019a1a0e208daad9ec Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a49040f37fc6663706470bfc5825077dedfd67e1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..69a4cecf0acf8c4517bdd412f2a7e9f099ecfb2b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/092_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..377227c614e86ce09cd07c26a32174029d50d215 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..665bf6cf22350cf926ef155e6cac8954157135aa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3cd3ada73d711bdc8021b2fa54082537098c8e88 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3ed3ffc8fece2332e03da4e3c05cb793fe6ee43a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bb8db03e832a3fa9ebcd84a2fc0d8cadcb2137ac Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7ee41b9785114bf599344f86d66934883f58a544 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f9c573f84f47bf2b799b99f36971581e262b6a5d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e50a555ddd9725aa356c108ad110efde6acc2d3f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d8c2ff7cdd19c09eb679b86c20f0f27bfce4c2b4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..768783f65b0a710fcf2ca7d1e5b15e3e9363a8dd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/093_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dcbecf42d385e8fa878c992ef6957e6d1742429a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..284226cf708d645377a50e99823f976312fd53cd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..77d1970817ed203b9ae905941d2dcfdf1b124717 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..095b367a5a682d877fa2bcf4f4642c5f447c3dbe Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2dd535eab50547ad81c01b25928510c0b39e99a5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a7bd3695bed21aacee7fff5ae3986d44b3e0fe70 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6811dd34f08548a9305c52df3f11269512c425f8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8b8b03ed58277cd2cc27006ada7c72e7eff002e0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fd0a9172647b0216ab039f217d2d5b099565040c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..17cba081d975bb15c30776e1d696cc9a76bd5e05 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/094_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c0cd04f6ba447293fdf5f8cbd4b6133d23b2669d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9a965dcf20cf162c51388c8c4118c461b43208e7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..98956b1473c370d8c788e10f1e0c8b6ed49fc8de Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b5d03312d914a5bf5a4bbfd33364521a97de5b60 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..de381f4d8672bacabf882ead8c139a80f32aa4ca Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6bcca653c9c0fed4dd2e6fd73061ad2931c18b64 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fb4d66eafece77918cd4cca82eadb7a8cfeb5aa8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..456d8845ae5cb719bb3fc36522da5bac416ac630 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..224236a2aabe48710b419cab11caf0a64b86baca Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..831589ddf4af89b5f378fe75550b269b22d861fa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/095_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f3b9e19ebf11b0daf7bd174fc5e78ca63a14d7b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8dcefb9190990c195e98da89171d417a5f723015 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e6b5280b62f3a6c904100a99999ca2f175cee073 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7ff681495d173343b79634072728909ce011d174 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9ad87b8e605134776769b880e378d68f4ae482a7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..633b3f01366142a132632d1029cc042e40eb1d47 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a24620babf937b777c21acc3fc457abfc28ddc1c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c67ba54a531f1230cd1818318a8af33f6087f628 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c9eb5fc6b3444ab39faed49669eff8959edcd327 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9042079babf08027639ae71b021c5dbc0b3f9c8e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/096_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d936a997ee57745f719d0457a8b78b48231d7a35 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..959f82514a5395ff2f6336cb758f03dcbf76b2cc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..62e8448ef1c36002f5d382923c32550471bcaf22 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..da6865e0c3818d64531c39f2bc83cf7ec09be5b6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cc8be39475a260810c723db52bb7ad6e9beb396b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a92021e709e56d1960edea90a36a4948987a99ae Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5e13277585c7128cefcffca87a7709cea44fcbe9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..db8e25c69067845eea0a7e19d46371c0b82a950d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..08932e7fa77ef5a52643b228f1a523cb668dcdb8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..418b4f195b7703d05e841e475a915e83cf70eb81 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/097_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b433c2750dcf55901b368f9475a0202cd478cccf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ee20e9ee4eb6e1a5f93c4c4b8b702e9892df5cde Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f5a6921a99d91268100449c4686ec8b98413f463 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bdd8d4359c183fe5adc88765ce21584380f6a700 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dd579bb75778f503f7388a425b48374a594c2b00 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..17ff74ecf1b1d61829f2dde6b4a7d992b26d083d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a184f9db97cea4b93bb950cd5893569a0ed5ca20 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aa22892b3db5ad536fa1fd1f4a56ca8c1b7f0ada Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f05d26a28bc3a2a9fba301f76674448b95a5647c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..30960a5a3da068d2227ae26e05b174938fa6d848 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/098_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5fee54b05ac74cfb43a64e5407386dc714d00706 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5cbe3a17b5d1a175e767f7ea51bc558e30709915 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8a647a86fbd8558ef8d7622950ee9d61407a2178 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2cf28684dff381252e94936c51281b707422888d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1fa8d1e213d59ef4e8739acbeff15a9cc86e21de Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c0b5a842a3f54df92ae575531caa56a0bf21e46c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..908c3a6219a197285983a42086e44b97b41017fa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..946edfabbff80e3a84d68a5d4bc2728caff578f8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..38102731f890e4b2d0fa87168ed2097489f8a033 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ae6b7301fee28c43e7809e9f4a4079293b97a46f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/099_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d4568eb86f5264c041038d740aef0372ca844018 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..82121aaec46619f686eb2e7ee6552dca4f9370f5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bc69a1d04200ba9e714558aa42f299ac3368468e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..040e18610332c0275eb6c255720e987fd00c62a6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8a8dd2308aec95c73c3fcdb9df0774dbfe16bb17 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3b083910a8a97f50e065b79c1bff42da766ec978 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0978cda052cad4a47fce92de892a71bacc1e95aa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8392c0dd0dff673202569487be5d6a171ef8a51e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..055555ec79ef34a87c60bc1e2cfdee96cb26134b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3a0dce4f9ade14e5106a59ccc2a8181a9c3e4ee0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8551c15c111ca5c17be94b97f2b3e6fa983f6165 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/100_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6b5a3814a64f3009d172a2f631426b7ae0d71b99 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d757932c9b1b8460bf625f425cd530ce45ffbaef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cb54241e5f30d545dfb896c2760f33bc6d1713bc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ce88a0c3ddd4ca42b754fb051c9579e1d16448f2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7b05c3c7ca8c5e94b73ec18d6f37efbdc37f7ef4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6645660a7863e749c00eb32d7aeb48b1e3f46e75 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..05ee20128d61c0df978475e4a503facbfe3ac094 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9a10ff90c26c19ae91343655b878954d5a2a1496 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b02858a61a2b107cdd1852003dc4c2ef09c97059 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e6a04b15d35e33d49fef90d4cf56df42a571be6e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/101_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c3aba64808934c1a47e5f951631e78d467de7824 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bb56b49f836c49618990db1528f7f019f50f5b11 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..191581b0a7d96ffbd2689b789b3e618d447c981c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6f087525086bdca3254d91c973c0abfb7e003754 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..822aed0991ad516475f2007b96038c393958c912 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..463b24943934c825b870464fc2913aea994ef9de Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0ee08d72bf63aa044227fa2af3f531a1c364acd4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..04e36f42908581393a67a772a990ceafa7bb20dc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fe84bdfd8969c0f386b7959aae9878e4274681b2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3ffdb627204b71024bd15ed2720fb989844cd2db Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/102_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3e166549ee12460686828a9ded1c176471feec86 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6447912ac510cfb40605dc366331e58b3212a9a9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a25062307a0b4efeb6f713ae53514fe1d3fabd43 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..aa9d4c9942aee52868e7485a28f91da541b42395 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d98cee7939fb5469e5a627c0d1fdf5645da0bc20 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f389bdbe197854e3a3e551b6bb90deba86bdd0c0 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..574588a3dbabdc738ddb415776241988bf4f37d9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..689cd560e2470825ff216982d5836ea1b7752d5c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6c94670456352ad4a0cfcbfda84a3a1cae40c2a6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..910e004f9ba29732d9bda4122583e552b9e24dcd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/103_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f2f10efc7d8548a1069a52fc74c7c5c1b87dc8b3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dd3ee329887382cdacb6ef223ee24c5d1b7d71e4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3a14d6bf2ccd38512c508708ca8764b1cf191fbf Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5494683ac9f783de16d8f344a976298512c3f1a7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..32be4262f4de463e749fbaa651264d818bf55c75 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0096b04a3cadbe831fba05d9bf0f9e1be2c4ae5d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3e1ceb2e9de7e91bbd516e5b367fe5ff87bba6b9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a57d9e38e469b579e6f65571efd3bd34b35cd1f8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..720bf4a7334f489bab51ada8ac3a2e7351008593 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..41a19e8af6b7291c5eaee6d800cf4b28f00bb6b5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/104_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2bfade14a0811b79c2e83f7b3dab18a2759fd0ba Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2649bdbde1fb5f2fa9e8b49de8a7e95cddd4bb80 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e295a6feb636e6b4ff3130fe043e56198ffb1feb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d7a836f4ccbece529e6e652794cd29bacfc6a34e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2674c098887584f128f11f82c88d4344cb3e64fc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5b02716dfcc35f994eb0cc80c99f38a5249942ba Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c3d6c8017ca967002a3516039d3df078120174bb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ea3e633267a6abfd722fdb62502bdd3d5c08eab8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1e7575eb8e9ba5f171e6d87963a3ddd0ef31e36 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..be85cbd43d4cd3435033c5e9209918a8cc6f23ef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/105_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..57873be2b4a9de8c38dbc13ab0e142971e2ec2a5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..86b3c5ad69edd59ef76e904db661e92e14d4037d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b403616b8d58d910178e5c9a9549909ac1678b78 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ad8b87981a54fdfbc2824af9624a302229750e92 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5fa952e1e748ead5cc31c75bb15895e0813f9269 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f4f2d5d903fbbe5fd177b7396bca934bb3c14f00 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ee70383bfc5f014006656c70621bd59c2f975fe5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a9704a0cca5f00e4594bf60e811fc0d04f121d46 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7d17d1c03e2036c2835751404c52130a34a5b46b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..13c676e2a5be007226edce1e0bfbae92a13bef53 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/106_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a2acb0347136932c02bb01008db90fd511e9060e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f67d3b67d0aafa2794b2bcbc8be57a7162fd575 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..339c05fb21cdb0a658b9d7ce28ec02ecebbf8c61 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..60ddf23028e56eb47f80a10ca2c38cbc425b623a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a4a4dbe93eab1cacceb43a89e3d8f0eba8d607f3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0885cbd90d3a8c9186de41650b1a6205e3ad8418 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..117244f276fffafa2902bc29b2becea8df04988b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9531f1b06e8616945a074ffd5d947be633ba6959 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6a25f85bce2669a3c9eb34200fe44ec0010d233c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..173f8e661d204f1eae670e74bb4c1d1cc737ba74 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/107_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ec541fb530b4e3d8d0c34b65259b41a4f2af15b4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dd9cb1f144c15fddfadd793ef8de681dfba3a629 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..77c27eb07b9957e8b4dd386608c643f7a1073b38 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f8426d7a2b7c249670eca66a360345676d13df7e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..09be9c798a67fcf53caf6ca2fbc17b6840208f3a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fa7d00c3c3c0a9e309462d3c1ca53fe3e969416d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b45713d259bf3b79dc424b4282416702ec3573fd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..22313ba772776788abaa17af3303c5697e05defa Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4412df9a9d17e0cbb3eb6079075bbb8d593d4e84 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b29131a1125a9029e20788a5bac8cb8fa22c8b65 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/108_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0148d7ce79a7485db9545187cfefcccaf4660903 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..36a96b69411c5be6c56bff29eddea04c133a333c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c2cf17021784ce0be086373d60cf913f801b5116 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a13d73d89f71179ad147986a446d4f1d272873df Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2986601df28155cabbc46fd76d3fd692275f36ef Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..faf4a9b149551e463450674e1e99c2c2bef0a960 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e47bb8f0bcd0cd72fbfd712b3b8eacb733fb3718 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cd58712d67827c4bd7c31f8b8636b8bdd9b88c7d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1bf4308f9b3d92a79e1119e47c115933a2fb6c3f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..876f3479cd62a5c8e9c77da82d11fcee7bfa4f2e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/109_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..397776a2ddf02e5bbf2a85000450aaeecb82f48d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..248b41abdf6457df8c9f3de0d7fe17eefa30585d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b13d47d2fe99b10c5ef6f12447232eedcb79173d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..90862e4b6415a14a08fe58a16e067e4931aaf889 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..20211a9bbaf6f17d3971c4224a2c63330ab31edd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..84eb68e6d9827abd9989a0ad282285e314a072fb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..60f1a572c6dd4f6e15001cf96519d9cc97da7a14 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c83eec5378e0a36a7119712395a94e1e7dd7eb37 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8486aa677a552806e77b768b9f396b885afae6de Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c9a6981028cde138189cdedaa06ac81edc8d4ab3 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/110_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c6f49d8d0eeb7f42a8aae2079219d406100ca1eb Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..77e5f1874e3e212bd66fd4cf87f8729396c95d5f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..192226a1389065493969543e66a9bf76fbfe2768 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1a4e346d2456d52b22c6fcbe9cb6503a97ba3f0f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..699dd3051b132cb7fdeb78deac42f2ccf5fd2110 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..cd9bcfb11bf4551bab422326b38a3a6d05e83f2a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..43814bdb11a32992ca4285b54b1811bc039ad4e5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f71d0b8ae09694f57a1ee036030a5fadf6ad3382 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..455b5881cca155170d90c347c728a191a3aa4927 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..21ebf0e2283033a7779dc62fc75e6031a1547792 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/111_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a9bd17466b0c1d8bfb35fb4c9499a1f7a38bca96 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3dc004204fcae9c989f776a70f92ea3eb934328f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f79eae23d1715c2483f9af7395ff7b30d9d0a6e9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..12f252bb9e15fdd1209eaa1a38a40697af13fb54 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c7773c201804a109059e50aec534d14708146094 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..de5ff4369c21672a12b7d2245ddc8300292a9ad6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5d8989dc08ee8d1cb2dd0868cb5ae83f2c24e2bc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e3e8f8e56dbb9440c336c4906467d443e3bba14f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..61c0f71c6bbeecca137c31d11650fd4bd7779d62 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f9b9b300ac8a8bc16dea1edba75c97e7a1c8d281 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/112_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4b73d72a1c82d3fd3e94b41f017b4a81de557d5d Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b2f7494fdf458dcb8d29277741a1b9f9300b20dc Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..34effed8d52013cfb9cd3486e0c12fbab65dad67 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ab8de7bfbd7b72c9222d326b4ae9bf10c666aaae Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4bd5fb0550eb955ddb75557b1ab2a881939ce401 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d7c8ed66057f112a5717b43b76ca744b9e13426c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e7f6352b0aefbf783d490bf0941b7b8470fe077e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..09b1d7966a9f3101ddc1be4977c22aa8ff9bc8c5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3d7b20ffc5de34700528cebb1216492a34cc9365 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3c2c808f17a6093da3f5a254b350d25724d07b0a Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/113_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..74769d561e8068ec067d0002bbafc8fa5cb7287f Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..848ff4f6f5cb94667c46623ce317f0ce77c191f7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f2aada72a72399d55ebd7852076d6455fe598421 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..06fc4824ec65ab2f94166d59743707f1fffb7ab5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3a91b24ac7f32becfc4e6f3dc36371c844d0ebbd Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d6cb7bfd5f1023c289514039a48ca432f698dd65 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..17f3620e58c71379ee6de0cbef55afc192d29ce1 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d5ec766b3588fe47884f32b58b11cb47d52ec134 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..521ccfdbadb8dc01d8913b47f2499cad9a1715d9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..91fab0f1e88e2552a92103a325281ac1d8fd5a29 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/114_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..64eebdb9e97bc31d5e98dbeed9d23c599c451c7c Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2987d86139bbf9c2c0c048374a2d70f50de85fed Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a867c002047fc10560cd0484386967fb9eaea105 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6d9b15a25ee3fbafe1ae80c135dc5099743ff095 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6e399262708c01e51ea153f519946e04b95d7fb5 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e36f9c61898de55a784f700bc8e29a87bf2a3527 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e1bc9c95c065ce1e6287b62e8ec9ecfa09150789 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3ca70c2a92764cc716ccac4c474c266366eb147e Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e2a4bd0fb6c2400b9a31dc140d791711c6332f55 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_8.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_8.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ef1685704cfae33f928af1239e264a6fbb1c5de6 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/115_8.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_0.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_0.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3a9510c09ae116b7166cadbb9e315402fc6d0bf7 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_0.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_1.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0074d8a088ae0604efed7de7fc8e6de65bee6ef9 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_1.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_10.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_10.jpg new file mode 100644 index 0000000000000000000000000000000000000000..80a403cafcbad88565357ba9359016a69f784a50 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_10.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..eeb3a873c9ffe9fab5bfc6e72a52bd014e35be31 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ea26f3b7fe5c58a3d57f943452763dd2e7e8e588 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_3.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_4.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_4.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fa941c75a45c1181e0b02f5cd57fa586114c2f17 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_4.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_5.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_5.jpg new file mode 100644 index 0000000000000000000000000000000000000000..372887fb8ad2c86c3bfcffc2b0aa2a2a3b1150d2 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_5.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_6.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_6.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e57880fb9c244b63cb5e4c39bde077e3ff37197b Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_6.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_7.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_7.jpg new file mode 100644 index 0000000000000000000000000000000000000000..af0c491e1480922c053ff9c4a4fcdc35aea443b4 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_7.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_9.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_9.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4109e90c1c0203bcd766c2f26af5020d58884815 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/116_9.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/2.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bb0e7ccec973103778fddb61758162c2394b7971 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/2.jpg differ diff --git a/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/3.jpg b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..db436797bbf7036a051f222697b7b9764abd65f8 Binary files /dev/null and b/best_practices/contrib/ganomaly/data/Mainboard/train/0.normal/3.jpg differ diff --git a/best_practices/contrib/ganomaly/eva.py b/best_practices/contrib/ganomaly/eva.py new file mode 100644 index 0000000000000000000000000000000000000000..66d5f1e63818f0ce1cadbfcb07e934ffd2d9ab29 --- /dev/null +++ b/best_practices/contrib/ganomaly/eva.py @@ -0,0 +1,68 @@ +""" Evaluate ROC +Returns: + auc, eer: Area under the curve, Equal Error Rate +""" + +# pylint: disable=C0103,C0301 + +## +# LIBRARIES +from __future__ import print_function + +import os +from sklearn.metrics import roc_curve, auc, average_precision_score, f1_score +from scipy.optimize import brentq +from scipy.interpolate import interp1d +import matplotlib.pyplot as plt +from matplotlib import rc +rc('font', **{'family': 'serif', 'serif': ['Computer Modern']}) +rc('text', usetex=True) + +def evaluate(labels, scores, metric='roc'): + if metric == 'roc': + return roc(labels, scores) + elif metric == 'auprc': + return auprc(labels, scores) + elif metric == 'f1_score': + threshold = 0.20 + scores[scores >= threshold] = 1 + scores[scores < threshold] = 0 + return f1_score(labels, scores) + else: + raise NotImplementedError("Check the evaluation metric.") + +## +def roc(labels, scores, saveto=None): + """Compute ROC curve and ROC area for each class""" + fpr = dict() + tpr = dict() + roc_auc = dict() + + + # True/False Positive Rates. + fpr, tpr, _ = roc_curve(labels, scores) + roc_auc = auc(fpr, tpr) + + # Equal Error Rate + eer = brentq(lambda x: 1. - x - interp1d(fpr, tpr)(x), 0., 1.) + + if saveto: + plt.figure() + lw = 2 + plt.plot(fpr, tpr, color='darkorange', lw=lw, label='(AUC = %0.2f, EER = %0.2f)' % (roc_auc, eer)) + plt.plot([eer], [1-eer], marker='o', markersize=5, color="navy") + plt.plot([0, 1], [1, 0], color='navy', lw=1, linestyle=':') + plt.xlim([0.0, 1.0]) + plt.ylim([0.0, 1.05]) + plt.xlabel('False Positive Rate') + plt.ylabel('True Positive Rate') + plt.title('Receiver operating characteristic') + plt.legend(loc="lower right") + plt.savefig(os.path.join(saveto, "ROC.pdf")) + plt.close() + + return roc_auc + +def auprc(labels, scores): + ap = average_precision_score(labels, scores) + return ap \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/ganomalyTest.py b/best_practices/contrib/ganomaly/ganomalyTest.py new file mode 100644 index 0000000000000000000000000000000000000000..58985931591a8dcf29ca8b129dead04bc9e6a5e5 --- /dev/null +++ b/best_practices/contrib/ganomaly/ganomalyTest.py @@ -0,0 +1,91 @@ +import cv2 as cv +import numpy as np +import os +import sys +import time + +path = os.path.dirname(os.path.abspath(__file__)) +sys.path.append(os.path.join(path, ".")) +#sys.path.append(os.path.join(path, "./acllite/")) +sys.path.insert(0, os.path.join(path, "acllite")) +print(sys.path) +from eva import roc +from constants import IMG_EXT +from acllite_model import AclLiteModel +from acllite_image import AclLiteImage +from acllite_resource import AclLiteResource + +INPUT_normal_DIR = './data/Mainboard/test/0.normal' +INPUT_abnormal_DIR = './data/Mainboard/test/1.abnormal' +OUTPUT_DIR = './out/' +model_d_path = './netD.om' +model_g_path = './netG.om' +img_size = 32 + + +def preprocess(picPath): + + bgr_img = cv.imread(picPath) + bgr_img = cv.resize(bgr_img,(img_size,img_size)).astype(np.float32) + # bgr_img = bgr_img.transpose((2,0,1)) + bgr_img = (bgr_img-np.min(bgr_img))/(np.max(bgr_img)-np.min(bgr_img)) + bgr_img = bgr_img - 0.5 + + if not bgr_img.flags['C_CONTIGUOUS']: + bgr_img = np.ascontiguousarray(bgr_img) + + return bgr_img + + +def main(): + """ + acl resource initialization + """ + if not os.path.exists(OUTPUT_DIR): + os.mkdir(OUTPUT_DIR) + + #ACL resource initialization + acl_resource = AclLiteResource() + acl_resource.init() + + netd = AclLiteModel(model_d_path) + netg = AclLiteModel(model_g_path) + + images_normal_list = [os.path.join(INPUT_normal_DIR, img) + for img in os.listdir(INPUT_normal_DIR) + if os.path.splitext(img)[1] in IMG_EXT] + images_abnormal_list = [os.path.join(INPUT_abnormal_DIR, img) + for img in os.listdir(INPUT_abnormal_DIR) + if os.path.splitext(img)[1] in IMG_EXT] + images_list = images_normal_list + images_abnormal_list + table = [] + for _ in images_normal_list: + table.append(0) + for _ in images_abnormal_list: + table.append(1) + an_scores = [] + for pic in images_list: + input = preprocess(pic) + fake = netg.execute([input,])[0] + _,feat_real = netd.execute([input,]) + _,feat_fake = netd.execute([fake.transpose((0,2,3,1)),]) + + rec = input - fake.transpose((0,2,3,1))[0] + rec = rec.reshape(-1) + rec = np.mean(rec**2) + + lat = feat_real - feat_fake + lat = lat.reshape(-1) + lat = np.mean(lat**2) + error = 0.9 * rec + 0.1 * lat + an_scores.append(error) + an_scores = np.array(an_scores) + an_scores = (an_scores-np.min(an_scores))/(np.max(an_scores)-np.min(an_scores)) + # an_scores = an_scores*100 + # for _ in range(len(table)): + # print(table[_],':',an_scores[_]*100) + auc = roc(table, an_scores) + print(auc) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/lib/data/dataloader.py b/best_practices/contrib/ganomaly/lib/data/dataloader.py new file mode 100644 index 0000000000000000000000000000000000000000..b6be4e60d8b6caefaccb45ac4a55f879462989f8 --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/data/dataloader.py @@ -0,0 +1,102 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +import os +from torchvision import transforms +from torch.utils.data import DataLoader +from torchvision.datasets import MNIST, CIFAR10, ImageFolder +from lib.data.datasets import get_cifar_anomaly_dataset +from lib.data.datasets import get_mnist_anomaly_dataset + +class Data: + """ Dataloader containing train and valid sets. + """ + def __init__(self, train, valid): + self.train = train + self.valid = valid + +## +def load_data(opt): + """ Load Data + + Args: + opt ([type]): Argument Parser + + Raises: + IOError: Cannot Load Dataset + + Returns: + [type]: dataloader + """ + + ## + # LOAD DATA SET + if opt.dataroot == '': + opt.dataroot = './data/{}'.format(opt.dataset) + + ## CIFAR + if opt.dataset in ['cifar10']: + transform = transforms.Compose([transforms.Resize(opt.isize), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) + + train_ds = CIFAR10(root='./data', train=True, download=True, transform=transform) + valid_ds = CIFAR10(root='./data', train=False, download=True, transform=transform) + train_ds, valid_ds = get_cifar_anomaly_dataset(train_ds, valid_ds, train_ds.class_to_idx[opt.abnormal_class]) + + ## MNIST + elif opt.dataset in ['mnist']: + transform = transforms.Compose([transforms.Resize(opt.isize), + transforms.ToTensor(), + transforms.Normalize((0.1307,), (0.3081,))]) + + + train_ds = MNIST(root='./data', train=True, download=True, transform=transform) + valid_ds = MNIST(root='./data', train=False, download=True, transform=transform) + train_ds, valid_ds = get_mnist_anomaly_dataset(train_ds, valid_ds, int(opt.abnormal_class)) + + # FOLDER + else: + transform = transforms.Compose([transforms.Resize(opt.isize), + transforms.CenterCrop(opt.isize), + transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]) + + train_ds = ImageFolder(os.path.join(opt.dataroot, 'train'), transform) + valid_ds = ImageFolder(os.path.join(opt.dataroot, 'test'), transform) + + ## DATALOADER + train_dl = DataLoader(dataset=train_ds, batch_size=opt.batchsize, shuffle=True, drop_last=True) + valid_dl = DataLoader(dataset=valid_ds, batch_size=opt.batchsize, shuffle=False, drop_last=False) + + return Data(train_dl, valid_dl) diff --git a/best_practices/contrib/ganomaly/lib/data/datasets.py b/best_practices/contrib/ganomaly/lib/data/datasets.py new file mode 100644 index 0000000000000000000000000000000000000000..ef06f3ae30e5a1d7669af3f63814a3249e6732e0 --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/data/datasets.py @@ -0,0 +1,337 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +import torch.utils.data as data +import torch +from random import shuffle +from torchvision.datasets import DatasetFolder + +from pathlib import Path +from PIL import Image +import numpy as np +import os +import os.path +import random +import imageio +import numpy as np + + +IMG_EXTENSIONS = [ + '.jpg', '.JPG', '.jpeg', '.JPEG', + '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP', + '.tif', '.TIF', '.tiff', '.TIFF' +] + +def is_image_file(filename): + return any(filename.endswith(extension) for extension in IMG_EXTENSIONS) + +def find_classes(dir): + classes = [d for d in os.listdir(dir) if os.path.isdir(os.path.join(dir, d))] + classes.sort() + class_to_idx = {classes[i]: i for i in range(len(classes))} + return classes, class_to_idx + +def make_dataset(dir, class_to_idx): + images = [] + dir = os.path.expanduser(dir) + for target in sorted(os.listdir(dir)): + d = os.path.join(dir, target) + if not os.path.isdir(d): + continue + + for root, _, fnames in sorted(os.walk(d)): + for fname in sorted(fnames): + if is_image_file(fname): + path = os.path.join(root, fname) + item = (path, class_to_idx[target]) + images.append(item) + + return images + +def pil_loader(path): + # open path as file to avoid ResourceWarning (https://github.com/python-pillow/Pillow/issues/835) + with open(path, 'rb') as f: + with Image.open(f) as img: + return img.convert('RGB') + +def accimage_loader(path): + import accimage + try: + return accimage.Image(path) + except IOError: + return pil_loader(path) + +def default_loader(path): + from torchvision import get_image_backend + if get_image_backend() == 'accimage': + return accimage_loader(path) + else: + return pil_loader(path) + +class ImageFolder(data.Dataset): + """A generic data loader where the images are arranged in this way: :: + + root/dog/xxx.png + root/dog/xxy.png + root/dog/xxz.png + + root/cat/123.png + root/cat/nsdf3.png + root/cat/asd932_.png + + Args: + root (string): Root directory path. + transform (callable, optional): A function/transform that takes in an PIL image + and returns a transformed version. E.g, ``transforms.RandomCrop`` + target_transform (callable, optional): A function/transform that takes in the + target and transforms it. + loader (callable, optional): A function to load an image given its path. + + Attributes: + classes (list): List of the class names. + class_to_idx (dict): Dict with items (class_name, class_index). + imgs (list): List of (image path, class_index) tuples + """ + + def __init__(self, root, nz=100, transform=None, target_transform=None, + loader=default_loader): + classes, class_to_idx = find_classes(root) + imgs = make_dataset(root, class_to_idx) + if len(imgs) == 0: + raise(RuntimeError("Found 0 images in subfolders of: " + root + "\n" + "Supported image extensions are: " + ",".join(IMG_EXTENSIONS))) + + self.root = root + self.imgs = imgs + self.noise = torch.FloatTensor(len(self.imgs), nz, 1, 1).normal_(0, 1) + self.classes = classes + self.class_to_idx = class_to_idx + self.transform = transform + self.target_transform = target_transform + self.loader = loader + + def __getitem__(self, index): + """ + Args: + index (int): Index + + Returns: + tuple: (image, target) where target is class_index of the target class. + """ + path, target = self.imgs[index] + img = self.loader(path) + if self.transform is not None: + img = self.transform(img) + + latentz = self.noise[index] + + # TODO: Return these variables in a dict. + # return img, latentz, index, target + return {'image': img, 'latentz': latentz, 'index': index, 'frame_gt': target} + + def __setitem__(self, index, value): + self.noise[index] = value + + def __len__(self): + return len(self.imgs) + +# TODO: refactor cifar-mnist anomaly dataset functions into one generic function. + +## +def get_cifar_anomaly_dataset(train_ds, valid_ds, abn_cls_idx=0): + """[summary] + Arguments: + train_ds {Dataset - CIFAR10} -- Training dataset + valid_ds {Dataset - CIFAR10} -- Validation dataset. + Keyword Arguments: + abn_cls_idx {int} -- Anomalous class index (default: {0}) + Returns: + [np.array] -- New training-test images and labels. + """ + + # Get images and labels. + trn_img, trn_lbl = train_ds.data, np.array(train_ds.targets) + tst_img, tst_lbl = valid_ds.data, np.array(valid_ds.targets) + + # -- + # Find idx, img, lbl for abnormal and normal on org dataset. + nrm_trn_idx = np.where(trn_lbl != abn_cls_idx)[0] + abn_trn_idx = np.where(trn_lbl == abn_cls_idx)[0] + nrm_trn_img = trn_img[nrm_trn_idx] # Normal training images + abn_trn_img = trn_img[abn_trn_idx] # Abnormal training images + nrm_trn_lbl = trn_lbl[nrm_trn_idx] # Normal training labels + abn_trn_lbl = trn_lbl[abn_trn_idx] # Abnormal training labels. + + nrm_tst_idx = np.where(tst_lbl != abn_cls_idx)[0] + abn_tst_idx = np.where(tst_lbl == abn_cls_idx)[0] + nrm_tst_img = tst_img[nrm_tst_idx] # Normal training images + abn_tst_img = tst_img[abn_tst_idx] # Abnormal training images. + nrm_tst_lbl = tst_lbl[nrm_tst_idx] # Normal training labels + abn_tst_lbl = tst_lbl[abn_tst_idx] # Abnormal training labels. + + # -- + # Assign labels to normal (0) and abnormals (1) + nrm_trn_lbl[:] = 0 + nrm_tst_lbl[:] = 0 + abn_trn_lbl[:] = 1 + abn_tst_lbl[:] = 1 + + # Create new anomaly dataset based on the following data structure: + # - anomaly dataset + # . -> train + # . -> normal + # . -> test + # . -> normal + # . -> abnormal + train_ds.data = np.copy(nrm_trn_img) + valid_ds.data = np.concatenate((nrm_tst_img, abn_trn_img, abn_tst_img), axis=0) + train_ds.targets = np.copy(nrm_trn_lbl) + valid_ds.targets = np.concatenate((nrm_tst_lbl, abn_trn_lbl, abn_tst_lbl), axis=0) + + return train_ds, valid_ds + +## +def get_mnist_anomaly_dataset(train_ds, valid_ds, abn_cls_idx=0): + """[summary] + Arguments: + train_ds {Dataset - MNIST} -- Training dataset + valid_ds {Dataset - MNIST} -- Validation dataset. + Keyword Arguments: + abn_cls_idx {int} -- Anomalous class index (default: {0}) + Returns: + [np.array] -- New training-test images and labels. + """ + + # Get images and labels. + trn_img, trn_lbl = train_ds.data, train_ds.targets + tst_img, tst_lbl = valid_ds.data, valid_ds.targets + + # -- + # Find normal abnormal indexes. + # TODO: PyTorch v0.4 has torch.where function + nrm_trn_idx = torch.from_numpy(np.where(trn_lbl.numpy() != abn_cls_idx)[0]) + abn_trn_idx = torch.from_numpy(np.where(trn_lbl.numpy() == abn_cls_idx)[0]) + nrm_tst_idx = torch.from_numpy(np.where(tst_lbl.numpy() != abn_cls_idx)[0]) + abn_tst_idx = torch.from_numpy(np.where(tst_lbl.numpy() == abn_cls_idx)[0]) + + # -- + # Find normal and abnormal images + nrm_trn_img = trn_img[nrm_trn_idx] # Normal training images + abn_trn_img = trn_img[abn_trn_idx] # Abnormal training images. + nrm_tst_img = tst_img[nrm_tst_idx] # Normal training images + abn_tst_img = tst_img[abn_tst_idx] # Abnormal training images. + + # -- + # Find normal and abnormal labels. + nrm_trn_lbl = trn_lbl[nrm_trn_idx] # Normal training labels + abn_trn_lbl = trn_lbl[abn_trn_idx] # Abnormal training labels. + nrm_tst_lbl = tst_lbl[nrm_tst_idx] # Normal training labels + abn_tst_lbl = tst_lbl[abn_tst_idx] # Abnormal training labels. + + # -- + # Assign labels to normal (0) and abnormals (1) + nrm_trn_lbl[:] = 0 + nrm_tst_lbl[:] = 0 + abn_trn_lbl[:] = 1 + abn_tst_lbl[:] = 1 + + # Create new anomaly dataset based on the following data structure: + train_ds.data = nrm_trn_img.clone() + valid_ds.data = torch.cat((nrm_tst_img, abn_trn_img, abn_tst_img), dim=0) + train_ds.targets = nrm_trn_lbl.clone() + valid_ds.targets = torch.cat((nrm_tst_lbl, abn_trn_lbl, abn_tst_lbl), dim=0) + + return train_ds, valid_ds + +## +def make_anomaly_dataset(train_ds, valid_ds, abn_cls_idx=0): + """[summary] + + Arguments: + train_ds {Dataset - MNIST} -- Training dataset + valid_ds {Dataset - MNIST} -- Validation dataset. + + Keyword Arguments: + abn_cls_idx {int} -- Anomalous class index (default: {0}) + + Returns: + [np.array] -- New training-test images and labels. + """ + + # Check the input type. + if isinstance(train_ds.data, np.ndarray): + train_ds.data = torch.from_numpy(train_ds.data) + valid_ds.data = torch.from_numpy(valid_ds.data) + train_ds.targets = torch.Tensor(train_ds.targets) + valid_ds.targets = torch.Tensor(valid_ds.targets) + + # Get images and labels. + trn_img, trn_lbl = train_ds.data, train_ds.targets + tst_img, tst_lbl = valid_ds.data, valid_ds.targets + + # -- + # Find normal abnormal indexes. + # TODO: PyTorch v0.4 has torch.where function + nrm_trn_idx = torch.from_numpy(np.where(trn_lbl.numpy() != abn_cls_idx)[0]) + abn_trn_idx = torch.from_numpy(np.where(trn_lbl.numpy() == abn_cls_idx)[0]) + nrm_tst_idx = torch.from_numpy(np.where(tst_lbl.numpy() != abn_cls_idx)[0]) + abn_tst_idx = torch.from_numpy(np.where(tst_lbl.numpy() == abn_cls_idx)[0]) + + # -- + # Find normal and abnormal images + nrm_trn_img = trn_img[nrm_trn_idx] # Normal training images + abn_trn_img = trn_img[abn_trn_idx] # Abnormal training images. + nrm_tst_img = tst_img[nrm_tst_idx] # Normal training images + abn_tst_img = tst_img[abn_tst_idx] # Abnormal training images. + + # -- + # Find normal and abnormal labels. + nrm_trn_lbl = trn_lbl[nrm_trn_idx] # Normal training labels + abn_trn_lbl = trn_lbl[abn_trn_idx] # Abnormal training labels. + nrm_tst_lbl = tst_lbl[nrm_tst_idx] # Normal training labels + abn_tst_lbl = tst_lbl[abn_tst_idx] # Abnormal training labels. + + # -- + # Assign labels to normal (0) and abnormals (1) + nrm_trn_lbl[:] = 0 + nrm_tst_lbl[:] = 0 + abn_trn_lbl[:] = 1 + abn_tst_lbl[:] = 1 + + # Create new anomaly dataset based on the following data structure: + train_ds.data = nrm_trn_img.clone() + valid_ds.data = torch.cat((nrm_tst_img, abn_trn_img, abn_tst_img), dim=0) + train_ds.targets = nrm_trn_lbl.clone() + valid_ds.targets = torch.cat((nrm_tst_lbl, abn_trn_lbl, abn_tst_lbl), dim=0) + + return train_ds, valid_ds diff --git a/best_practices/contrib/ganomaly/lib/evaluate.py b/best_practices/contrib/ganomaly/lib/evaluate.py new file mode 100644 index 0000000000000000000000000000000000000000..df6c5e4d37a02ea6798d9ceb1eb1cbf63bc4cb48 --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/evaluate.py @@ -0,0 +1,96 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +from __future__ import print_function + +import os +from sklearn.metrics import roc_curve, auc, average_precision_score, f1_score +from scipy.optimize import brentq +from scipy.interpolate import interp1d +import matplotlib.pyplot as plt +from matplotlib import rc +rc('font', **{'family': 'serif', 'serif': ['Computer Modern']}) +rc('text', usetex=True) + + +def evaluate(labels, scores, metric='roc'): + if metric == 'roc': + return roc(labels, scores) + elif metric == 'auprc': + return auprc(labels, scores) + elif metric == 'f1_score': + threshold = 0.20 + scores[scores >= threshold] = 1 + scores[scores < threshold] = 0 + return f1_score(labels, scores) + else: + raise NotImplementedError("Check the evaluation metric.") + + +## +def roc(labels, scores, saveto=None): + """Compute ROC curve and ROC area for each class""" + fpr = dict() + tpr = dict() + roc_auc = dict() + + labels = labels.cpu() + scores = scores.cpu() + + # True/False Positive Rates. + fpr, tpr, _ = roc_curve(labels, scores) + roc_auc = auc(fpr, tpr) + + # Equal Error Rate + eer = brentq(lambda x: 1. - x - interp1d(fpr, tpr)(x), 0., 1.) + + if saveto: + plt.figure() + lw = 2 + plt.plot(fpr, tpr, color='darkorange', lw=lw, label='(AUC = %0.2f, EER = %0.2f)' % (roc_auc, eer)) + plt.plot([eer], [1-eer], marker='o', markersize=5, color="navy") + plt.plot([0, 1], [1, 0], color='navy', lw=1, linestyle=':') + plt.xlim([0.0, 1.0]) + plt.ylim([0.0, 1.05]) + plt.xlabel('False Positive Rate') + plt.ylabel('True Positive Rate') + plt.title('Receiver operating characteristic') + plt.legend(loc="lower right") + plt.savefig(os.path.join(saveto, "ROC.pdf")) + plt.close() + + return roc_auc + +def auprc(labels, scores): + ap = average_precision_score(labels, scores) + return ap \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/lib/loss.py b/best_practices/contrib/ganomaly/lib/loss.py new file mode 100644 index 0000000000000000000000000000000000000000..b4135f21dc41b803f4255cb9b9f34619fc53b670 --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/loss.py @@ -0,0 +1,64 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +import torch + +## +def l1_loss(input, target): + """ L1 Loss without reduce flag. + + Args: + input (FloatTensor): Input tensor + target (FloatTensor): Output tensor + + Returns: + [FloatTensor]: L1 distance between input and output + """ + + return torch.mean(torch.abs(input - target)) + + +def l2_loss(input, target, size_average=True): + """ L2 Loss without reduce flag. + + Args: + input (FloatTensor): Input tensor + target (FloatTensor): Output tensor + + Returns: + [FloatTensor]: L2 distance between input and output + """ + if size_average: + return torch.mean(torch.pow((input-target), 2)) + else: + return torch.pow((input-target), 2) diff --git a/best_practices/contrib/ganomaly/lib/models/__init__.py b/best_practices/contrib/ganomaly/lib/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aa4f9a53c16a4eb20308de37a377d0b07dcd7c69 --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/models/__init__.py @@ -0,0 +1,53 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +import importlib + +## +def load_model(opt, dataloader): + """ Load model based on the model name. + + Arguments: + opt {[argparse.Namespace]} -- options + dataloader {[dict]} -- dataloader class + + Returns: + [model] -- Returned model + """ + + model_name = opt.model # skipganomaly or ganomaly + model_path = f"lib.models.{model_name}" + model_lib = importlib.import_module(model_path) + model = getattr(model_lib, model_name.title()) + + return model(opt, dataloader) \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/lib/models/basemodel.py b/best_practices/contrib/ganomaly/lib/models/basemodel.py new file mode 100644 index 0000000000000000000000000000000000000000..09ddaee0e3e5101b9b7fdd7837066fad18f3d91b --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/models/basemodel.py @@ -0,0 +1,335 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +from collections import OrderedDict +import os +import time +import numpy as np +from tqdm import tqdm +import pandas as pd +import seaborn as sns +import matplotlib.pyplot as plt +from PIL import Image + +from torch.autograd import Variable +import torch.optim as optim +import torch.nn as nn +import torch.utils.data +import torchvision.utils as vutils +import torch_npu + +from lib.models.networks import NetD, weights_init, define_G, define_D, get_scheduler +from lib.visualizer import Visualizer +from lib.loss import l2_loss +from lib.evaluate import roc, evaluate + + +class BaseModel(): + """ Base Model for ganomaly + """ + def __init__(self, opt, data): + ## + # Seed for deterministic behavior + self.seed(opt.manualseed) + + # Initalize variables. + self.opt = opt + self.visualizer = Visualizer(opt) + self.data = data + self.trn_dir = os.path.join(self.opt.outf, self.opt.name, 'train') + self.tst_dir = os.path.join(self.opt.outf, self.opt.name, 'test') + self.device = 'npu' + + ## + def seed(self, seed_value): + """ Seed + + Arguments: + seed_value {int} -- [description] + """ + # Check if seed is default value + if seed_value == -1: + return + + # Otherwise seed all functionality + import random + random.seed(seed_value) + torch.manual_seed(seed_value) + torch_npu.npu.manual_seed_all(seed_value) + np.random.seed(seed_value) + torch.backends.cudnn.deterministic = True + + ## + def set_input(self, input:torch.Tensor, noise:bool=False): + """ Set input and ground truth + + Args: + input (FloatTensor): Input data for batch i. + """ + with torch.no_grad(): + self.input.resize_(input[0].size()).copy_(input[0]) + self.gt.resize_(input[1].size()).copy_(input[1]) + self.label.resize_(input[1].size()) + + # Add noise to the input. + if noise: self.noise.data.copy_(torch.randn(self.noise.size())) + + # Copy the first batch as the fixed input. + if self.total_steps == self.opt.batchsize: + self.fixed_input.resize_(input[0].size()).copy_(input[0]) + + ## + def get_errors(self): + """ Get netD and netG errors. + + Returns: + [OrderedDict]: Dictionary containing errors. + """ + errors = OrderedDict([ + ('err_d', self.err_d.item()), + ('err_g', self.err_g.item()), + ('err_g_adv', self.err_g_adv.item()), + ('err_g_con', self.err_g_con.item()), + ('err_g_lat', self.err_g_lat.item())]) + + return errors + + ## + def reinit_d(self): + """ Initialize the weights of netD + """ + self.netd.apply(weights_init) + print('Reloading d net') + + ## + def get_current_images(self): + """ Returns current images. + + Returns: + [reals, fakes, fixed] + """ + + reals = self.input.data + fakes = self.fake.data + fixed = self.netg(self.fixed_input)[0].data + + return reals, fakes, fixed + + ## + def save_weights(self, epoch:int, is_best:bool=False): + """Save netG and netD weights for the current epoch. + + Args: + epoch ([int]): Current epoch number. + """ + + weight_dir = os.path.join( + self.opt.outf, self.opt.name, 'train', 'weights') + if not os.path.exists(weight_dir): + os.makedirs(weight_dir) + + if is_best: + torch.save({'epoch': epoch, 'state_dict': self.netg.state_dict()}, f'{weight_dir}/netG_best.pth') + torch.save({'epoch': epoch, 'state_dict': self.netd.state_dict()}, f'{weight_dir}/netD_best.pth') + else: + torch.save({'epoch': epoch, 'state_dict': self.netd.state_dict()}, f"{weight_dir}/netD_{epoch}.pth") + torch.save({'epoch': epoch, 'state_dict': self.netg.state_dict()}, f"{weight_dir}/netG_{epoch}.pth") + + def load_weights(self, epoch=None, is_best:bool=False, path=None): + """ Load pre-trained weights of NetG and NetD + + Keyword Arguments: + epoch {int} -- Epoch to be loaded (default: {None}) + is_best {bool} -- Load the best epoch (default: {False}) + path {str} -- Path to weight file (default: {None}) + + Raises: + Exception -- [description] + IOError -- [description] + """ + + if epoch is None and is_best is False: + raise Exception('Please provide epoch to be loaded or choose the best epoch.') + + if is_best: + fname_g = f"netG_best.pth" + fname_d = f"netD_best.pth" + else: + fname_g = f"netG_{epoch}.pth" + fname_d = f"netD_{epoch}.pth" + + if path is None: + path_g = f"./output/{self.name}/{self.opt.dataset}/train/weights/{fname_g}" + path_d = f"./output/{self.name}/{self.opt.dataset}/train/weights/{fname_d}" + + # Load the weights of netg and netd. + print('>> Loading weights...') + weights_g = torch.load(path_g)['state_dict'] + weights_d = torch.load(path_d)['state_dict'] + try: + self.netg.load_state_dict(weights_g) + self.netd.load_state_dict(weights_d) + except IOError: + raise IOError("netG weights not found") + print(' Done.') + + ## + def train_one_epoch(self): + """ Train the model for one epoch. + """ + + self.netg.train() + epoch_iter = 0 + for data in tqdm(self.data.train, leave=False, total=len(self.data.train)): + self.total_steps += self.opt.batchsize + epoch_iter += self.opt.batchsize + + self.set_input(data) + self.optimize_params() + + if self.total_steps % self.opt.print_freq == 0: + errors = self.get_errors() + if self.opt.display: + counter_ratio = float(epoch_iter) / len(self.data.train.dataset) + self.visualizer.plot_current_errors(self.epoch, counter_ratio, errors) + + if self.total_steps % self.opt.save_image_freq == 0: + reals, fakes, fixed = self.get_current_images() + self.visualizer.save_current_images(self.epoch, reals, fakes, fixed) + if self.opt.display: + self.visualizer.display_current_images(reals, fakes, fixed) + + print(">> Training model %s. Epoch %d/%d" % (self.name, self.epoch+1, self.opt.niter)) + + ## + def train(self): + """ Train the model + """ + # TRAIN + self.total_steps = 0 + best_auc = 0 + + # Train for niter epochs. + print(f">> Training {self.name} on {self.opt.dataset} to detect {self.opt.abnormal_class}, batchsize={self.opt.batchsize}, isize={self.opt.isize}") + for self.epoch in range(self.opt.iter, self.opt.niter): + self.train_one_epoch() + res = self.test() + if res['AUC'] > best_auc: + best_auc = res['AUC'] + self.save_weights(self.epoch, is_best = True) + self.visualizer.print_current_performance(res, best_auc) + print(">> Training model %s.[Done]" % self.name) + + ## + def test(self): + """ Test GANomaly model. + + Args: + data ([type]): Dataloader for the test set + + Raises: + IOError: Model weights not found. + """ + with torch.no_grad(): + # Load the weights of netg and netd. + if self.opt.load_weights: + path = "./output/{}/{}/train/weights/netG.pth".format(self.name.lower(), self.opt.dataset) + pretrained_dict = torch.load(path)['state_dict'] + + try: + self.netg.load_state_dict(pretrained_dict) + except IOError: + raise IOError("netG weights not found") + print(' Loaded weights.') + + self.opt.phase = 'test' + + # Create big error tensor for the test set. + self.an_scores = torch.zeros(size=(len(self.data.valid.dataset),), dtype=torch.float32, device=self.device) + self.gt_labels = torch.zeros(size=(len(self.data.valid.dataset),), dtype=torch.long, device=self.device) + self.latent_i = torch.zeros(size=(len(self.data.valid.dataset), self.opt.nz), dtype=torch.float32, device=self.device) + self.latent_o = torch.zeros(size=(len(self.data.valid.dataset), self.opt.nz), dtype=torch.float32, device=self.device) + + # print(" Testing model %s." % self.name) + self.times = [] + self.total_steps = 0 + epoch_iter = 0 + for i, data in enumerate(self.data.valid, 0): + self.total_steps += self.opt.batchsize + epoch_iter += self.opt.batchsize + time_i = time.time() + self.set_input(data) + self.fake, latent_i, latent_o = self.netg(self.input) + + error = torch.mean(torch.pow((latent_i-latent_o), 2), dim=1) + time_o = time.time() + + self.an_scores[i*self.opt.batchsize : i*self.opt.batchsize+error.size(0)] = error.reshape(error.size(0)) + self.gt_labels[i*self.opt.batchsize : i*self.opt.batchsize+error.size(0)] = self.gt.reshape(error.size(0)) + self.latent_i [i*self.opt.batchsize : i*self.opt.batchsize+error.size(0), :] = latent_i.reshape(error.size(0), self.opt.nz) + self.latent_o [i*self.opt.batchsize : i*self.opt.batchsize+error.size(0), :] = latent_o.reshape(error.size(0), self.opt.nz) + + self.times.append(time_o - time_i) + + # Save test images. + if self.opt.save_test_images: + dst = os.path.join(self.opt.outf, self.opt.name, 'test', 'images') + if not os.path.isdir(dst): + os.makedirs(dst) + real, fake, _ = self.get_current_images() + vutils.save_image(real, '%s/real_%03d.eps' % (dst, i+1), normalize=True) + vutils.save_image(fake, '%s/fake_%03d.eps' % (dst, i+1), normalize=True) + + # Measure inference time. + self.times = np.array(self.times) + self.times = np.mean(self.times[:100] * 1000) + + # Scale error vector between [0, 1] + self.an_scores = (self.an_scores - torch.min(self.an_scores)) / (torch.max(self.an_scores) - torch.min(self.an_scores)) + auc = evaluate(self.gt_labels, self.an_scores, metric=self.opt.metric) + performance = OrderedDict([('Avg Run Time (ms/batch)', self.times), ('AUC', auc)]) + + if self.opt.display_id > 0 and self.opt.phase == 'test': + counter_ratio = float(epoch_iter) / len(self.data.valid.dataset) + self.visualizer.plot_performance(self.epoch, counter_ratio, performance) + return performance + + ## + def update_learning_rate(self): + """ Update learning rate based on the rule provided in options. + """ + + for scheduler in self.schedulers: + scheduler.step() + lr = self.optimizers[0].param_groups[0]['lr'] + print(' LR = %.7f' % lr) \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/lib/models/ganomaly.py b/best_practices/contrib/ganomaly/lib/models/ganomaly.py new file mode 100644 index 0000000000000000000000000000000000000000..f0edf6f78e18454aea2f37ce0bc2543ee7ac61d9 --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/models/ganomaly.py @@ -0,0 +1,229 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +from collections import OrderedDict +import os +import time +import numpy as np +from tqdm import tqdm + +from torch.autograd import Variable +import torch.optim as optim +import torch.nn as nn +import torch.utils.data +import torchvision.utils as vutils + +from lib.models.networks import NetG, NetD, weights_init +from lib.visualizer import Visualizer +from lib.loss import l2_loss +from lib.evaluate import evaluate +from lib.models.basemodel import BaseModel + +## +class Ganomaly(BaseModel): + @property + def name(self): return 'Ganomaly' + + def __init__(self, opt, data): + super(Ganomaly, self).__init__(opt, data) + + # -- Misc attributes + self.epoch = 0 + self.times = [] + self.total_steps = 0 + + ## + # Create and initialize networks. + self.netg = NetG(self.opt).to(self.device) + self.netd = NetD(self.opt).to(self.device) + self.netg.apply(weights_init) + self.netd.apply(weights_init) + + ## + if self.opt.resume != '': + print("\nLoading pre-trained networks.") + self.opt.iter = torch.load(os.path.join(self.opt.resume, 'netG.pth'))['epoch'] + self.netg.load_state_dict(torch.load(os.path.join(self.opt.resume, 'netG.pth'))['state_dict']) + self.netd.load_state_dict(torch.load(os.path.join(self.opt.resume, 'netD.pth'))['state_dict']) + print("\tDone.\n") + + self.l_adv = l2_loss + self.l_con = nn.L1Loss() + self.l_enc = l2_loss + self.l_bce = nn.BCELoss() + + ## + # Initialize input tensors. + self.input = torch.empty(size=(self.opt.batchsize, 3, self.opt.isize, self.opt.isize), dtype=torch.float32, device=self.device) + self.label = torch.empty(size=(self.opt.batchsize,), dtype=torch.float32, device=self.device) + self.gt = torch.empty(size=(opt.batchsize,), dtype=torch.long, device=self.device) + self.fixed_input = torch.empty(size=(self.opt.batchsize, 3, self.opt.isize, self.opt.isize), dtype=torch.float32, device=self.device) + self.real_label = torch.ones (size=(self.opt.batchsize,), dtype=torch.float32, device=self.device) + self.fake_label = torch.zeros(size=(self.opt.batchsize,), dtype=torch.float32, device=self.device) + ## + # Setup optimizer + if self.opt.isTrain: + self.netg.train() + self.netd.train() + self.optimizer_d = optim.Adam(self.netd.parameters(), lr=self.opt.lr, betas=(self.opt.beta1, 0.999)) + self.optimizer_g = optim.Adam(self.netg.parameters(), lr=self.opt.lr, betas=(self.opt.beta1, 0.999)) + + ## + def forward_g(self): + """ Forward propagate through netG + """ + self.fake, self.latent_i, self.latent_o = self.netg(self.input) + + ## + def forward_d(self): + """ Forward propagate through netD + """ + self.pred_real, self.feat_real = self.netd(self.input) + self.pred_fake, self.feat_fake = self.netd(self.fake.detach()) + + ## + def backward_g(self): + """ Backpropagate through netG + """ + self.err_g_adv = self.opt.w_adv * self.l_adv(self.feat_fake, self.feat_real) + self.err_g_con = self.opt.w_con * self.l_con(self.fake, self.input) + self.err_g_lat = self.opt.w_lat * self.l_enc(self.latent_o, self.latent_i) + + self.err_g = self.err_g_adv + self.err_g_con + self.err_g_lat + self.err_g.backward(retain_graph=True) + + ## + def backward_d(self): + """ Backpropagate through netD + """ + # Real - Fake Loss + self.err_d_real = self.l_bce(self.pred_real, self.real_label) + self.err_d_fake = self.l_bce(self.pred_fake, self.fake_label) + + # NetD Loss & Backward-Pass + self.err_d = (self.err_d_real + self.err_d_fake) * 0.5 + self.err_d.backward() + + ## + def optimize_params(self): + """ Forwardpass, Loss Computation and Backwardpass. + """ + # Forward-pass + self.forward_g() + self.forward_d() + + # Backward-pass + # netg + self.optimizer_g.zero_grad() + self.backward_g() + self.optimizer_g.step() + + # netd + self.optimizer_d.zero_grad() + self.backward_d() + self.optimizer_d.step() + if self.err_d.item() < 1e-5: self.reinit_d() + + ## + def test(self): + """ Test GANomaly model. + + Args: + data ([type]): data for the test set + + Raises: + IOError: Model weights not found. + """ + with torch.no_grad(): + # Load the weights of netg and netd. + if self.opt.load_weights: + path = "./output/{}/{}/train/weights/netG.pth".format(self.name.lower(), self.opt.dataset) + pretrained_dict = torch.load(path)['state_dict'] + + try: + self.netg.load_state_dict(pretrained_dict) + except IOError: + raise IOError("netG weights not found") + print(' Loaded weights.') + + self.opt.phase = 'test' + + # Create big error tensor for the test set. + self.an_scores = torch.zeros(size=(len(self.data.valid.dataset),), dtype=torch.float32, device=self.device) + self.gt_labels = torch.zeros(size=(len(self.data.valid.dataset),), dtype=torch.long, device=self.device) + self.latent_i = torch.zeros(size=(len(self.data.valid.dataset), self.opt.nz), dtype=torch.float32, device=self.device) + self.latent_o = torch.zeros(size=(len(self.data.valid.dataset), self.opt.nz), dtype=torch.float32, device=self.device) + + # print(" Testing model %s." % self.name) + self.times = [] + self.total_steps = 0 + epoch_iter = 0 + for i, data in enumerate(self.data.valid, 0): + self.total_steps += self.opt.batchsize + epoch_iter += self.opt.batchsize + time_i = time.time() + self.set_input(data) + self.fake, latent_i, latent_o = self.netg(self.input) + + error = torch.mean(torch.pow((latent_i-latent_o), 2), dim=1) + time_o = time.time() + + self.an_scores[i*self.opt.batchsize : i*self.opt.batchsize+error.size(0)] = error.reshape(error.size(0)) + self.gt_labels[i*self.opt.batchsize : i*self.opt.batchsize+error.size(0)] = self.gt.reshape(error.size(0)) + self.latent_i [i*self.opt.batchsize : i*self.opt.batchsize+error.size(0), :] = latent_i.reshape(error.size(0), self.opt.nz) + self.latent_o [i*self.opt.batchsize : i*self.opt.batchsize+error.size(0), :] = latent_o.reshape(error.size(0), self.opt.nz) + + self.times.append(time_o - time_i) + + # Save test images. + if self.opt.save_test_images: + dst = os.path.join(self.opt.outf, self.opt.name, 'test', 'images') + if not os.path.isdir(dst): + os.makedirs(dst) + real, fake, _ = self.get_current_images() + vutils.save_image(real, '%s/real_%03d.eps' % (dst, i+1), normalize=True) + vutils.save_image(fake, '%s/fake_%03d.eps' % (dst, i+1), normalize=True) + + # Measure inference time. + self.times = np.array(self.times) + self.times = np.mean(self.times[:100] * 1000) + + # Scale error vector between [0, 1] + self.an_scores = (self.an_scores - torch.min(self.an_scores)) / (torch.max(self.an_scores) - torch.min(self.an_scores)) + auc = evaluate(self.gt_labels, self.an_scores, metric=self.opt.metric) + performance = OrderedDict([('Avg Run Time (ms/batch)', self.times), ('AUC', auc)]) + + if self.opt.display_id > 0 and self.opt.phase == 'test': + counter_ratio = float(epoch_iter) / len(self.data.valid.dataset) + self.visualizer.plot_performance(self.epoch, counter_ratio, performance) + return performance diff --git a/best_practices/contrib/ganomaly/lib/models/layers.py b/best_practices/contrib/ganomaly/lib/models/layers.py new file mode 100644 index 0000000000000000000000000000000000000000..d224ed26a6e06c1ace11dc7de7085b466bb950d9 --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/models/layers.py @@ -0,0 +1,289 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +import torch +from torch import nn +import torch.nn.functional as F + + +class DepthToSpace(nn.Module): + + def __init__(self, block_size): + super(DepthToSpace,self).__init__() + self.bs = block_size + + def forward(self, x): + N, C, H, W = x.size() + x = x.view(N, self.bs, self.bs, C // (self.bs ** 2), H, W) # (N, bs, bs, C//bs^2, H, W) + x = x.permute(0, 3, 4, 1, 5, 2).contiguous() # (N, C//bs^2, H, bs, W, bs) + x = x.view(N, C // (self.bs ** 2), H * self.bs, W * self.bs) # (N, C//bs^2, H * bs, W * bs) + return x + + +class SpaceToDepth(nn.Module): + # Taken from https://discuss.pytorch.org/t/is-there-any-layer-like-tensorflows-space-to-depth-function/3487/14 + # Expects the following shape: Batch, Channel, Height, Width + def __init__(self, block_size): + super().__init__() + self.bs = block_size + + def forward(self, x): + N, C, H, W = x.size() + x = x.view(N, C, H // self.bs, self.bs, W // self.bs, self.bs) # (N, C, H//bs, bs, W//bs, bs) + x = x.permute(0, 3, 5, 1, 2, 4).contiguous() # (N, bs, bs, C, H//bs, W//bs) + x = x.view(N, C * (self.bs ** 2), H // self.bs, W // self.bs) # (N, C*bs^2, H//bs, W//bs) + return x + + +class DepthwiseSeparableConv(nn.Module): + def __init__(self, in_channels, output_channels, kernel_size, padding=0, kernels_per_layer=1): + super(DepthwiseSeparableConv, self).__init__() + # In Tensorflow DepthwiseConv2D has depth_multiplier instead of kernels_per_layer + self.depthwise = nn.Conv2d(in_channels, in_channels * kernels_per_layer, kernel_size=kernel_size, padding=padding, + groups=in_channels) + self.pointwise = nn.Conv2d(in_channels * kernels_per_layer, output_channels, kernel_size=1) + + def forward(self, x): + x = self.depthwise(x) + x = self.pointwise(x) + return x + + +class DoubleDense(nn.Module): + def __init__(self, in_channels, hidden_neurons, output_channels): + super(DoubleDense, self).__init__() + self.dense1 = nn.Linear(in_channels, out_features=hidden_neurons) + self.dense2 = nn.Linear(in_features=hidden_neurons, out_features=hidden_neurons // 2) + self.dense3 = nn.Linear(in_features=hidden_neurons // 2, out_features=output_channels) + + def forward(self, x): + out = F.relu(self.dense1(x.view(x.size(0), -1))) + out = F.relu(self.dense2(out)) + out = self.dense3(out) + return out + + +class DoubleDSConv(nn.Module): + """(convolution => [BN] => ReLU) * 2""" + def __init__(self, in_channels, out_channels): + super().__init__() + self.double_ds_conv = nn.Sequential( + DepthwiseSeparableConv(in_channels, out_channels, kernel_size=3, padding=1), + nn.BatchNorm2d(out_channels), + nn.ReLU(inplace=True), + DepthwiseSeparableConv(out_channels, out_channels, kernel_size=3, padding=1), + nn.BatchNorm2d(out_channels), + nn.ReLU(inplace=True) + ) + + def forward(self, x): + return self.double_ds_conv(x) + + +class Flatten(nn.Module): + def forward(self, x): + return x.view(x.size(0), -1) + + +class ChannelAttention(nn.Module): + def __init__(self, input_channels, reduction_ratio=16): + super(ChannelAttention, self).__init__() + self.input_channels = input_channels + self.avg_pool = nn.AdaptiveAvgPool2d(1) + self.max_pool = nn.AdaptiveMaxPool2d(1) + # https://github.com/luuuyi/CBAM.PyTorch/blob/master/model/resnet_cbam.py + # uses Convolutions instead of Linear + self.MLP = nn.Sequential( + Flatten(), + nn.Linear(input_channels, input_channels // reduction_ratio), + nn.ReLU(), + nn.Linear(input_channels // reduction_ratio, input_channels) + ) + + def forward(self, x): + # Take the input and apply average and max pooling + avg_values = self.avg_pool(x) + max_values = self.max_pool(x) + out = self.MLP(avg_values) + self.MLP(max_values) + scale = x * torch.sigmoid(out).unsqueeze(2).unsqueeze(3).expand_as(x) + return scale + + +class SpatialAttention(nn.Module): + def __init__(self, kernel_size=7): + super(SpatialAttention, self).__init__() + assert kernel_size in (3, 7), 'kernel size must be 3 or 7' + padding = 3 if kernel_size == 7 else 1 + self.conv = nn.Conv2d(2, 1, kernel_size=kernel_size, padding=padding, bias=False) + self.bn = nn.BatchNorm2d(1) + + def forward(self, x): + avg_out = torch.mean(x, dim=1, keepdim=True) + max_out, _ = torch.max(x, dim=1, keepdim=True) + out = torch.cat([avg_out, max_out], dim=1) + out = self.conv(out) + out = self.bn(out) + scale = x * torch.sigmoid(out) + return scale + + +class CBAM(nn.Module): + def __init__(self, input_channels, reduction_ratio=16, kernel_size=7): + super(CBAM, self).__init__() + self.channel_att = ChannelAttention(input_channels, reduction_ratio=reduction_ratio) + self.spatial_att = SpatialAttention(kernel_size=kernel_size) + + def forward(self, x): + out = self.channel_att(x) + out = self.spatial_att(out) + return out + + +# ============================================================ proposed +class SoftPool2d(torch.nn.Module): + def __init__(self, kernel_size=2, strides=None, padding=0, ceil_mode=False, count_include_pad=True, + divisor_override=None): + super(SoftPool2d, self).__init__() + self.avgpool = torch.nn.AvgPool2d(kernel_size, strides, padding, ceil_mode, count_include_pad, divisor_override) + + def forward(self, x): + x_exp = torch.exp(x) + x_exp_pool = self.avgpool(x_exp) + x = self.avgpool(x_exp * x) + return x / x_exp_pool + + +class SEBlock(nn.Module): + def __init__(self, mode, channels, reduction_ratio): + super(SEBlock, self).__init__() + self.avg_pooling = nn.AdaptiveAvgPool2d(1) + self.max_pooling = nn.AdaptiveMaxPool2d(1) + if mode == "max": + self.global_pooling = self.max_pooling + elif mode == "avg": + self.global_pooling = self.avg_pooling + self.fc_layers = nn.Sequential( + nn.Linear(in_features=channels, out_features=channels // reduction_ratio, bias=False), + nn.ReLU(), + nn.Linear(in_features=channels // reduction_ratio, out_features=channels, bias=False), + ) + self.sigmoid = nn.Sigmoid() + + def forward(self, x): + b, c, _, _ = x.shape + v = self.global_pooling(x).view(b, c) + v = self.fc_layers(v).view(b, c, 1, 1) + v = self.sigmoid(v) + return x * v + + +class SEBlock_light(nn.Module): + def __init__(self, mode, channels, reduction_ratio): + super(SEBlock_light, self).__init__() + self.avg_pooling = nn.AdaptiveAvgPool2d(1) + self.max_pooling = nn.AdaptiveMaxPool2d(1) + if mode == "max": + self.global_pooling = self.max_pooling + elif mode == "avg": + self.global_pooling = self.avg_pooling + self.fc_layers = nn.Sequential( + nn.Linear(in_features=channels, out_features=channels // reduction_ratio, bias=False), + nn.ReLU(), + nn.Linear(in_features=channels // reduction_ratio, out_features=channels, bias=False), + ) + self.h_sigmoid = h_swish() + + def forward(self, x): + b, c, _, _ = x.shape + v = self.global_pooling(x).view(b, c) + v = self.fc_layers(v).view(b, c, 1, 1) + v = self.h_sigmoid(v) + return x * v + + +# ================================================================== Ablation experiments +class h_sigmoid(nn.Module): + def __init__(self, inplace=True): + super(h_sigmoid, self).__init__() + self.relu = nn.ReLU6(inplace=inplace) + + def forward(self, x): + return self.relu(x + 3) / 6 + + +class h_swish(nn.Module): + def __init__(self, inplace=True): + super(h_swish, self).__init__() + self.sigmoid = h_sigmoid(inplace=inplace) + + def forward(self, x): + return x * self.sigmoid(x) + + +class CoordAtt(nn.Module): + """Coordinate Attention""" + def __init__(self, inp, oup, reduction_ratio=32): + super(CoordAtt, self).__init__() + self.pool_h = nn.AdaptiveAvgPool2d((None, 1)) + self.pool_w = nn.AdaptiveAvgPool2d((1, None)) + + mip = max(8, inp // reduction_ratio) + + self.conv1 = nn.Conv2d(inp, mip, kernel_size=1, stride=1, padding=0) + self.bn1 = nn.BatchNorm2d(mip) + self.act = h_swish() + + self.conv_h = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0) + self.conv_w = nn.Conv2d(mip, oup, kernel_size=1, stride=1, padding=0) + + def forward(self, x): + identity = x + + n, c, h, w = x.size() + x_h = self.pool_h(x) + x_w = self.pool_w(x).permute(0, 1, 3, 2) + + y = torch.cat([x_h, x_w], dim=2) + y = self.conv1(y) + y = self.bn1(y) + y = self.act(y) + + x_h, x_w = torch.split(y, [h, w], dim=2) + x_w = x_w.permute(0, 1, 3, 2) + + a_h = self.conv_h(x_h).sigmoid() + a_w = self.conv_w(x_w).sigmoid() + + out = identity * a_w * a_h + + return out \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/lib/models/networks.py b/best_practices/contrib/ganomaly/lib/models/networks.py new file mode 100644 index 0000000000000000000000000000000000000000..20f661a972fd024122c1c1f0c0e1454737c30240 --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/models/networks.py @@ -0,0 +1,786 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +import torch +import torch.nn as nn +import torch.nn.parallel +import functools +from torch.optim import lr_scheduler +from torch.nn import init +import numpy as np + +from .unet_parts import * +from .layers import * + +from torchvision import utils as vutils +import datetime +from PIL import Image +import scipy.io as io + + +def weights_init(mod): + """ + Custom weights initialization called on netG, netD and netE + :param m: + :return: + """ + classname = mod.__class__.__name__ + if classname.find('Conv') != -1: + mod.weight.data.normal_(0.0, 0.02) + elif classname.find('BatchNorm') != -1: + mod.weight.data.normal_(1.0, 0.02) + mod.bias.data.fill_(0) + + +### +class Encoder(nn.Module): + """ + DCGAN ENCODER NETWORK + """ + + def __init__(self, isize, nz, nc, ndf, ngpu, n_extra_layers=0, add_final_conv=True): + super(Encoder, self).__init__() + self.ngpu = ngpu + assert isize % 16 == 0, "isize has to be a multiple of 16" + + main = nn.Sequential() + # input is nc x isize x isize + main.add_module('initial-conv-{0}-{1}'.format(nc, ndf), + nn.Conv2d(nc, ndf, 4, 2, 1, bias=False)) + main.add_module('initial-relu-{0}'.format(ndf), + nn.LeakyReLU(0.2, inplace=True)) + csize, cndf = isize / 2, ndf + # Extra layers + for t in range(n_extra_layers): + main.add_module('extra-layers-{0}-{1}-conv'.format(t, cndf), + nn.Conv2d(cndf, cndf, 3, 1, 1, bias=False)) + main.add_module('extra-layers-{0}-{1}-batchnorm'.format(t, cndf), + nn.BatchNorm2d(cndf)) + main.add_module('extra-layers-{0}-{1}-relu'.format(t, cndf), + nn.LeakyReLU(0.2, inplace=True)) + + while csize > 4: + in_feat = cndf + out_feat = cndf * 2 + main.add_module('pyramid-{0}-{1}-conv'.format(in_feat, out_feat), + nn.Conv2d(in_feat, out_feat, 4, 2, 1, bias=False)) + main.add_module('pyramid-{0}-batchnorm'.format(out_feat), + nn.BatchNorm2d(out_feat)) + main.add_module('pyramid-{0}-relu'.format(out_feat), + nn.LeakyReLU(0.2, inplace=True)) + cndf = cndf * 2 + csize = csize / 2 + + # state size. K x 4 x 4 + if add_final_conv: + main.add_module('final-{0}-{1}-conv'.format(cndf, 1), + nn.Conv2d(cndf, nz, 4, 1, 0, bias=False)) + + self.main = main + + def forward(self, input): + if isinstance(input.data, torch.cuda.FloatTensor) and self.ngpu > 1: + output = nn.parallel.data_parallel(self.main, input, range(self.ngpu)) + else: + output = self.main(input) + + return output + + +class Decoder(nn.Module): + """ + DCGAN DECODER NETWORK + """ + + def __init__(self, isize, nz, nc, ngf, ngpu, n_extra_layers=0): + super(Decoder, self).__init__() + self.ngpu = ngpu + assert isize % 16 == 0, "isize has to be a multiple of 16" + + cngf, tisize = ngf // 2, 4 + while tisize != isize: + cngf = cngf * 2 + tisize = tisize * 2 + + main = nn.Sequential() + # input is Z, going into a convolution + main.add_module('initial-{0}-{1}-convt'.format(nz, cngf), + nn.ConvTranspose2d(nz, cngf, 4, 1, 0, bias=False)) + main.add_module('initial-{0}-batchnorm'.format(cngf), + nn.BatchNorm2d(cngf)) + main.add_module('initial-{0}-relu'.format(cngf), + nn.ReLU(True)) + + csize, _ = 4, cngf + while csize < isize // 2: + main.add_module('pyramid-{0}-{1}-convt'.format(cngf, cngf // 2), + nn.ConvTranspose2d(cngf, cngf // 2, 4, 2, 1, bias=False)) + main.add_module('pyramid-{0}-batchnorm'.format(cngf // 2), + nn.BatchNorm2d(cngf // 2)) + main.add_module('pyramid-{0}-relu'.format(cngf // 2), + nn.ReLU(True)) + cngf = cngf // 2 + csize = csize * 2 + + # Extra layers + for t in range(n_extra_layers): + main.add_module('extra-layers-{0}-{1}-conv'.format(t, cngf), + nn.Conv2d(cngf, cngf, 3, 1, 1, bias=False)) + main.add_module('extra-layers-{0}-{1}-batchnorm'.format(t, cngf), + nn.BatchNorm2d(cngf)) + main.add_module('extra-layers-{0}-{1}-relu'.format(t, cngf), + nn.ReLU(True)) + + main.add_module('final-{0}-{1}-convt'.format(cngf, nc), + nn.ConvTranspose2d(cngf, nc, 4, 2, 1, bias=False)) + main.add_module('final-{0}-tanh'.format(nc), + nn.Tanh()) + self.main = main + + def forward(self, input): + if isinstance(input.data, torch.cuda.FloatTensor) and self.ngpu > 1: + output = nn.parallel.data_parallel(self.main, input, range(self.ngpu)) + else: + output = self.main(input) + return output + + +## +class BasicDiscriminator(nn.Module): + """ + NETD + """ + + def __init__(self, opt): + super(BasicDiscriminator, self).__init__() + isize = opt.isize + nz = opt.nz + nc = opt.nc + ngf = opt.ngf + ndf = opt.ndf + n_extra_layers = 0 + self.ngpu = opt.ngpu + assert isize % 16 == 0, "isize has to be a multiple of 16" + + feat = nn.Sequential() + clas = nn.Sequential() + # input is nc x isize x isize + feat.add_module('initial-conv-{0}-{1}'.format(nc, ndf), + nn.Conv2d(nc, ndf, 4, 2, 1, bias=False)) + # feat.add_module('initial-conv-{0}-{1}'.format(nc, ndf), + # DepthwiseSeparableConv(nc, ndf, kernel_size=4, + # kernels_per_layer=1, + # padding=1)) + feat.add_module('initial-relu-{0}'.format(ndf), + nn.LeakyReLU(0.2, inplace=True)) + csize, cndf = isize / 2, ndf + + # Extra layers + for t in range(n_extra_layers): + feat.add_module('extra-layers-{0}-{1}-conv'.format(t, cndf), + nn.Conv2d(cndf, cndf, 3, 1, 1, bias=False)) + # feat.add_module('extra-layers-{0}-{1}-conv'.format(nc, ndf), + # DepthwiseSeparableConv(cndf, cndf, kernel_size=3, + # kernels_per_layer=1, + # padding=1)) + feat.add_module('extra-layers-{0}-{1}-batchnorm'.format(t, cndf), + nn.BatchNorm2d(cndf)) + feat.add_module('extra-layers-{0}-{1}-relu'.format(t, cndf), + nn.LeakyReLU(0.2, inplace=True)) + + while csize > 4: + in_feat = cndf + out_feat = cndf * 2 + feat.add_module('pyramid-{0}-{1}-conv'.format(in_feat, out_feat), + nn.Conv2d(in_feat, out_feat, 4, 2, 1, bias=False)) + # feat.add_module('pyramid-{0}-{1}-conv'.format(nc, ndf), + # DepthwiseSeparableConv(in_feat, out_feat, kernel_size=4, + # kernels_per_layer=2, + # padding=1)) + feat.add_module('pyramid-{0}-batchnorm'.format(out_feat), + nn.BatchNorm2d(out_feat)) + feat.add_module('pyramid-{0}-relu'.format(out_feat), + nn.LeakyReLU(0.2, inplace=True)) + cndf = cndf * 2 + csize = csize / 2 + + # state size. K x 4 x 4 + # main.add_module('final-{0}-{1}-conv'.format(cndf, 1), + # nn.Conv2d(cndf, nz, 4, 1, 0, bias=False)) + feat.add_module('final-{0}-{1}-conv'.format(cndf, 1), + nn.Conv2d(cndf, nz, 4, 1, 0, bias=False)) + # feat.add_module('final-{0}-{1}-conv'.format(nc, ndf), + # DepthwiseSeparableConv(cndf, nz, kernel_size=4, + # kernels_per_layer=1, + # padding=0)) + clas.add_module('classifier', nn.Conv2d(nz, 1, 3, 1, 1, bias=False)) + clas.add_module('Sigmoid', nn.Sigmoid()) + + self.feat = feat + self.clas = clas + + def forward(self, input): + if isinstance(input.data, torch.cuda.FloatTensor) and self.ngpu > 1: + feat = nn.parallel.data_parallel(self.feat, input, range(self.ngpu)) + clas = nn.parallel.data_parallel(self.clas, feat, range(self.ngpu)) + else: + feat = self.feat(input) + clas = self.clas(feat) + clas = clas.view(-1, 1).squeeze(1) + return clas, feat + + +## +class NetD(nn.Module): + """ + DISCRIMINATOR NETWORK + """ + + def __init__(self, opt): + super(NetD, self).__init__() + model = Encoder(opt.isize, 1, opt.nc, opt.ngf, opt.ngpu, opt.extralayers) + layers = list(model.main.children()) + + self.features = nn.Sequential(*layers[:-1]) + self.classifier = nn.Sequential(layers[-1]) + # self.features.add_module('ConvFeauture', ) + self.classifier.add_module('Sigmoid', nn.Sigmoid()) + + def forward(self, x): + features = self.features(x) + features = features + classifier = self.classifier(features) + classifier = classifier.view(-1, 1).squeeze(1) + + return classifier, features + + +## +class NetG(nn.Module): + """ + GENERATOR NETWORK + """ + + def __init__(self, opt): + super(NetG, self).__init__() + self.encoder1 = Encoder(opt.isize, opt.nz, opt.nc, opt.ngf, opt.ngpu, opt.extralayers) + self.decoder = Decoder(opt.isize, opt.nz, opt.nc, opt.ngf, opt.ngpu, opt.extralayers) + self.encoder2 = Encoder(opt.isize, opt.nz, opt.nc, opt.ngf, opt.ngpu, opt.extralayers) + + def forward(self, x): + latent_i = self.encoder1(x) + gen_imag = self.decoder(latent_i) + latent_o = self.encoder2(gen_imag) + return gen_imag, latent_i, latent_o + + +############################################################################### +# Helper Functions +############################################################################### +## +def get_norm_layer(norm_type='instance'): + if norm_type == 'batch': + norm_layer = functools.partial(nn.BatchNorm2d, affine=True) + elif norm_type == 'instance': + norm_layer = functools.partial(nn.InstanceNorm2d, affine=False, track_running_stats=True) + elif norm_type == 'none': + norm_layer = None + else: + raise NotImplementedError('normalization layer [%s] is not found' % norm_type) + return norm_layer + + +## +def get_scheduler(optimizer, opt): + if opt.lr_policy == 'lambda': + def lambda_rule(epoch): + lr_l = 1.0 - max(0, epoch + 1 + opt.iter - opt.niter) / float(opt.niter_decay + 1) + return lr_l + + scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda_rule) + elif opt.lr_policy == 'step': + scheduler = lr_scheduler.StepLR(optimizer, step_size=opt.lr_decay_iters, gamma=0.1) + elif opt.lr_policy == 'plateau': + scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.2, threshold=0.01, patience=5) + else: + return NotImplementedError('learning rate policy [%s] is not implemented', opt.lr_policy) + return scheduler + + +## +def init_weights(net, init_type='normal', gain=0.02): + def init_func(m): + classname = m.__class__.__name__ + if hasattr(m, 'weight') and (classname.find('Conv') != -1 or classname.find('Linear') != -1): + if init_type == 'normal': + init.normal_(m.weight.data, 0.0, gain) + elif init_type == 'xavier': + init.xavier_normal_(m.weight.data, gain=gain) + elif init_type == 'kaiming': + init.kaiming_normal_(m.weight.data, a=0, mode='fan_in') + elif init_type == 'orthogonal': + init.orthogonal_(m.weight.data, gain=gain) + else: + raise NotImplementedError('initialization method [%s] is not implemented' % init_type) + if hasattr(m, 'bias') and m.bias is not None: + init.constant_(m.bias.data, 0.0) + elif classname.find('BatchNorm2d') != -1: + init.normal_(m.weight.data, 1.0, gain) + init.constant_(m.bias.data, 0.0) + + net.apply(init_func) + + +## +def init_net(net, init_type='normal', gpu_ids=""): + net.to(gpu_ids) + init_weights(net, init_type) + return net + + +## +def define_G(opt, norm='batch', use_dropout=False, init_type='normal'): + netG = None + norm_layer = get_norm_layer(norm_type=norm) + num_layer = int(np.log2(opt.isize)) + # netG = UnetGenerator(opt.nc, opt.nc, num_layer, opt.ngf, norm_layer=norm_layer, use_dropout=use_dropout) + netG = UNet_Abnormal(opt.nc) + + return init_net(netG, init_type, opt.loc) + + +## +def define_D(opt, norm='batch', use_sigmoid=False, init_type='normal'): + netD = None + norm_layer = get_norm_layer(norm_type=norm) + netD = BasicDiscriminator(opt) + + return init_net(netD, init_type, opt.loc) + + +############################################################################## +# Classes +############################################################################## +# Defines the GAN loss which uses either LSGAN or the regular GAN. +# When LSGAN is used, it is basically same as MSELoss, +# but it abstracts away the need to create the target label tensor +# that has the same size as the input +class GANLoss(nn.Module): + def __init__(self, use_lsgan=True, target_real_label=1.0, target_fake_label=0.0): + super(GANLoss, self).__init__() + self.register_buffer('real_label', torch.tensor(target_real_label)) + self.register_buffer('fake_label', torch.tensor(target_fake_label)) + if use_lsgan: + self.loss = nn.MSELoss() + else: + self.loss = nn.BCELoss() + + def get_target_tensor(self, input, target_is_real): + if target_is_real: + target_tensor = self.real_label + else: + target_tensor = self.fake_label + return target_tensor.expand_as(input) + + def __call__(self, input, target_is_real): + target_tensor = self.get_target_tensor(input, target_is_real) + return self.loss(input, target_tensor) + + +# Defines the generator that consists of Resnet blocks between a few +# downsampling/upsampling operations. +# Code and idea originally from Justin Johnson's architecture. +# https://github.com/jcjohnson/fast-neural-style/ +class ResnetGenerator(nn.Module): + def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, + padding_type='reflect'): + assert (n_blocks >= 0) + super(ResnetGenerator, self).__init__() + self.input_nc = input_nc + self.output_nc = output_nc + self.ngf = ngf + if type(norm_layer) == functools.partial: + use_bias = norm_layer.func == nn.InstanceNorm2d + else: + use_bias = norm_layer == nn.InstanceNorm2d + + model = [nn.ReflectionPad2d(3), + nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, + bias=use_bias), + norm_layer(ngf), + nn.ReLU(True)] + + n_downsampling = 2 + for i in range(n_downsampling): + mult = 2 ** i + model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, + stride=2, padding=1, bias=use_bias), + norm_layer(ngf * mult * 2), + nn.ReLU(True)] + + mult = 2 ** n_downsampling + for i in range(n_blocks): + model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, + use_bias=use_bias)] + + for i in range(n_downsampling): + mult = 2 ** (n_downsampling - i) + model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2), + kernel_size=3, stride=2, + padding=1, output_padding=1, + bias=use_bias), + norm_layer(int(ngf * mult / 2)), + nn.ReLU(True)] + model += [nn.ReflectionPad2d(3)] + model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)] + model += [nn.Tanh()] + + self.model = nn.Sequential(*model) + + def forward(self, input): + return self.model(input) + + +# Define a resnet block +class ResnetBlock(nn.Module): + def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias): + super(ResnetBlock, self).__init__() + self.conv_block = self.build_conv_block(dim, padding_type, norm_layer, use_dropout, use_bias) + + def build_conv_block(self, dim, padding_type, norm_layer, use_dropout, use_bias): + conv_block = [] + p = 0 + if padding_type == 'reflect': + conv_block += [nn.ReflectionPad2d(1)] + elif padding_type == 'replicate': + conv_block += [nn.ReplicationPad2d(1)] + elif padding_type == 'zero': + p = 1 + else: + raise NotImplementedError('padding [%s] is not implemented' % padding_type) + + conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), + norm_layer(dim), + nn.ReLU(True)] + if use_dropout: + conv_block += [nn.Dropout(0.5)] + + p = 0 + if padding_type == 'reflect': + conv_block += [nn.ReflectionPad2d(1)] + elif padding_type == 'replicate': + conv_block += [nn.ReplicationPad2d(1)] + elif padding_type == 'zero': + p = 1 + else: + raise NotImplementedError('padding [%s] is not implemented' % padding_type) + conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias), + norm_layer(dim)] + + return nn.Sequential(*conv_block) + + def forward(self, x): + out = x + self.conv_block(x) + return out + + +class UNet_Ganomaly(nn.Module): + def __init__(self, input_nc): + super(UNet_Ganomaly, self).__init__() + # def __init__(self, hparams): + # super(UNet, self).__init__(hparams=hparams) + self.n_channels = input_nc + self.n_classes = 3 + self.bilinear = True + + self.inc = DoubleConv(self.n_channels, 64) + self.down1 = Down(64, 128) + self.down2 = Down(128, 256) + self.down3 = Down(256, 512) + factor = 2 if self.bilinear else 1 + self.down4 = Down(512, 1024 // factor) + self.up1 = Up(1024, 512 // factor, self.bilinear) + self.up2 = Up(512, 256 // factor, self.bilinear) + self.up3 = Up(256, 128 // factor, self.bilinear) + self.up4 = Up(128, 64, self.bilinear) + + self.outc = OutConv(64, self.n_classes) + + def forward(self, x): + x1 = self.inc(x) + x2 = self.down1(x1) + x3 = self.down2(x2) + x4 = self.down3(x3) + x5 = self.down4(x4) + x = self.up1(x5, x4) + x = self.up2(x, x3) + x = self.up3(x, x2) + x = self.up4(x, x1) + logits = self.outc(x) + return logits + + +class UNet_Abnormal(nn.Module): + def __init__(self, input_nc): + """ + Args: + input_nc: 输入的通道数量 + DSS + MSC + """ + super(UNet_Abnormal, self).__init__() + self.n_channels = input_nc + self.n_classes = 3 + self.bilinear = False # + + # Encoder + self.inc = DoubleResidualConvSE(self.n_channels, 64) + self.sa1 = SpatialAttention(kernel_size=7) + self.down1 = DownSE(64, 128) + self.sa2 = SpatialAttention(kernel_size=7) + self.down2 = DownSE(128, 256) + self.sa3 = SpatialAttention(kernel_size=7) + self.down3 = DownSE(256, 512) + self.sa4 = SpatialAttention(kernel_size=7) + self.down4 = DownSE(512, 512) # + + # 是否需要线性插值 + factor = 2 if self.bilinear else 1 + + # latent representation + self.mult1 = DownconvBlock_layer1(64, 256) + self.mult2 = DownconvBlock_layer2(128, 256) + self.conv = nn.Conv2d(512, 512, kernel_size=1) + self.conv1 = conv1x1(1024, 1024) + + self.up1 = Up(1024, 512 // factor, self.bilinear) + self.up2 = Up(512, 256 // factor, self.bilinear) + self.up3 = Up(256, 128 // factor, self.bilinear) + self.up4 = Up(128, 64, self.bilinear) + self.outc = OutConv(64, self.n_classes) + + def forward(self, x): + x1 = self.inc(x) # 第一层输出 + x1Att = self.sa1(x1) + x2 = self.down1(x1) # 第二层输出 + x2Att = self.sa2(x2) + x3 = self.down2(x2) # 第三层输出 + x3Att = self.sa3(x3) + x4 = self.down3(x3) # 第四层输出 + x4Att = self.sa4(x4) # 注意力特征图 + x5 = self.down4(x4) # 第五层 + + # Msc + multi1 = self.mult1(x1) + multi2 = self.mult2(x2) + x5concat = torch.cat((multi1, multi2), 1) + x5conv_1 = self.conv(x5concat) + x5concat_ = torch.cat((x5conv_1, x5), 1) + x5multi = self.conv1(x5concat_) + + x = self.up1(x5multi, x4Att) + x = self.up2(x, x3Att) + x = self.up3(x, x2Att) + x = self.up4(x, x1Att) + + logits = self.outc(x) + return logits + + +# Defines the Unet generator. +# |num_downs|: number of downsamplings in UNet. For example, +# if |num_downs| == 7, image of size 128x128 will become of size 1x1 +# at the bottleneck +class UnetGenerator(nn.Module): + def __init__(self, input_nc, output_nc, num_downs, ngf=64, + norm_layer=nn.BatchNorm2d, use_dropout=False): + super(UnetGenerator, self).__init__() + + # construct unet structure + unet_block = UnetSkipConnectionBlock(ngf * 8, ngf * 8, input_nc=None, submodule=None, norm_layer=norm_layer, + innermost=True) + for i in range(num_downs - 5): + unet_block = UnetSkipConnectionBlock(ngf * 8, ngf * 8, input_nc=None, submodule=unet_block, + norm_layer=norm_layer, use_dropout=use_dropout) + unet_block = UnetSkipConnectionBlock(ngf * 4, ngf * 8, input_nc=None, submodule=unet_block, + norm_layer=norm_layer) + unet_block = UnetSkipConnectionBlock(ngf * 2, ngf * 4, input_nc=None, submodule=unet_block, + norm_layer=norm_layer) + unet_block = UnetSkipConnectionBlock(ngf, ngf * 2, input_nc=None, submodule=unet_block, norm_layer=norm_layer) + unet_block = UnetSkipConnectionBlock(output_nc, ngf, input_nc=input_nc, submodule=unet_block, outermost=True, + norm_layer=norm_layer) + + self.model = unet_block + + def forward(self, input): + # return self.model(input), latent + return self.model(input) + + +# Defines the submodule with skip connection. +# X -------------------identity---------------------- X +# |-- downsampling -- |submodule| -- upsampling --| +class UnetSkipConnectionBlock(nn.Module): + def __init__(self, outer_nc, inner_nc, input_nc=None, + submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False): + super(UnetSkipConnectionBlock, self).__init__() + self.outermost = outermost + self.innermost = innermost + if type(norm_layer) == functools.partial: + use_bias = norm_layer.func == nn.InstanceNorm2d + else: + use_bias = norm_layer == nn.InstanceNorm2d + if input_nc is None: + input_nc = outer_nc + downconv = nn.Conv2d(input_nc, inner_nc, kernel_size=4, + stride=2, padding=1, bias=use_bias) + # Conv to Pool + # downconv = nn.Sequential(SoftPool2d(), nn.Conv2d(input_nc, inner_nc, kernel_size=1)) + + downrelu = nn.LeakyReLU(0.2, True) + downnorm = norm_layer(inner_nc) + uprelu = nn.ReLU(True) + upnorm = norm_layer(outer_nc) + + if outermost: + upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc, + kernel_size=4, stride=2, + padding=1) + down = [downconv] + up = [uprelu, upconv, nn.Tanh()] + model = down + [submodule] + up + elif innermost: + upconv = nn.ConvTranspose2d(inner_nc, outer_nc, + kernel_size=4, stride=2, + padding=1, bias=use_bias) + down = [downrelu, downconv] + up = [uprelu, upconv, upnorm] + model = down + up + else: + upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc, + kernel_size=4, stride=2, + padding=1, bias=use_bias) + down = [downrelu, downconv, downnorm] + up = [uprelu, upconv, upnorm] + + if use_dropout: + model = down + [submodule] + up + [nn.Dropout(0.5)] + else: + model = down + [submodule] + up + + self.model = nn.Sequential(*model) + + def forward(self, x): + # global latent + # if self.outermost: + # self.test = self.model(x) # [torch.cuda.FloatTensor of size 1x512x2x2 (GPU 6)] + # return self.test + # elif self.innermost: + # latent = self.model(x) + # return torch.cat([latent, x], 1) + if self.outermost: + return self.model(x) + else: + return torch.cat([x, self.model(x)], 1) + + +# Defines the PatchGAN discriminator with the specified arguments. +class NLayerDiscriminator(nn.Module): + def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d, use_sigmoid=False): + super(NLayerDiscriminator, self).__init__() + if type(norm_layer) == functools.partial: + use_bias = norm_layer.func == nn.InstanceNorm2d + else: + use_bias = norm_layer == nn.InstanceNorm2d + + kw = 4 + padw = 1 + sequence = [ + nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw), + nn.LeakyReLU(0.2, True) + ] + + nf_mult = 1 + nf_mult_prev = 1 + for n in range(1, n_layers): + nf_mult_prev = nf_mult + nf_mult = min(2 ** n, 8) + sequence += [ + nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, + kernel_size=kw, stride=2, padding=padw, bias=use_bias), + norm_layer(ndf * nf_mult), + nn.LeakyReLU(0.2, True) + ] + + nf_mult_prev = nf_mult + nf_mult = min(2 ** n_layers, 8) + sequence += [ + nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, + kernel_size=kw, stride=1, padding=padw, bias=use_bias), + norm_layer(ndf * nf_mult), + nn.LeakyReLU(0.2, True) + ] + + sequence += [nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=1, padding=padw)] + + if use_sigmoid: + sequence += [nn.Sigmoid()] + + self.model = nn.Sequential(*sequence) + + def forward(self, input): + return self.model(input) + + +class PixelDiscriminator(nn.Module): + def __init__(self, input_nc, ndf=64, norm_layer=nn.BatchNorm2d, use_sigmoid=False): + super(PixelDiscriminator, self).__init__() + if type(norm_layer) == functools.partial: + use_bias = norm_layer.func == nn.InstanceNorm2d + else: + use_bias = norm_layer == nn.InstanceNorm2d + + self.net = [ + nn.Conv2d(input_nc, ndf, kernel_size=1, stride=1, padding=0), + nn.LeakyReLU(0.2, True), + nn.Conv2d(ndf, ndf * 2, kernel_size=1, stride=1, padding=0, bias=use_bias), + norm_layer(ndf * 2), + nn.LeakyReLU(0.2, True), + nn.Conv2d(ndf * 2, 1, kernel_size=1, stride=1, padding=0, bias=use_bias)] + + if use_sigmoid: + self.net.append(nn.Sigmoid()) + + self.net = nn.Sequential(*self.net) + + def forward(self, input): + return self.net(input) diff --git a/best_practices/contrib/ganomaly/lib/models/skipganomaly.py b/best_practices/contrib/ganomaly/lib/models/skipganomaly.py new file mode 100644 index 0000000000000000000000000000000000000000..036c188e12b0e77495b9c7246955ec8737cb1b9e --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/models/skipganomaly.py @@ -0,0 +1,339 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +from collections import OrderedDict +import os +import time +import numpy as np +from tqdm import tqdm + +import torch.optim as optim +import torch.nn as nn +import torch.utils.data +import torchvision.utils as vutils + +import pandas as pd +import seaborn as sns +import matplotlib.pyplot as plt + +from lib.models.networks import NetD, weights_init, define_G, define_D, get_scheduler +from lib.visualizer import Visualizer +from lib.loss import l2_loss +from lib.evaluate import roc +from lib.models.basemodel import BaseModel +import torch_npu +import scipy.io as io + +from apex import amp +from apex.optimizers import NpuFusedAdam +import torch + + +class Skipganomaly(BaseModel): + """GANomaly Class + """ + + @property + def name(self): + return 'skip-ganomaly' + + def __init__(self, opt, data=None): + super(Skipganomaly, self).__init__(opt, data) + ## + + # -- Misc attributes + self.add_noise = True + self.epoch = 0 + self.times = [] + self.total_steps = 0 + + ## + # Create and initialize networks. + self.netg = define_G(self.opt, norm='batch', use_dropout=False, init_type='normal') + self.netd = define_D(self.opt, norm='batch', use_sigmoid=False, init_type='normal') + + # input = torch.randn(1, 3, 32, 32) + # macs, params = profile(self.netg, inputs=(input,)) + # # macs, params = clever_format([macs, params], "%.3f") + # print(macs) + # print(params) + + ## + if self.opt.resume != '': + print("\nLoading pre-trained networks.") + self.opt.iter = torch.load(os.path.join(self.opt.resume, 'netG.pth'))['epoch'] + self.netg.load_state_dict(torch.load(os.path.join(self.opt.resume, 'netG.pth'))['state_dict']) + self.netd.load_state_dict(torch.load(os.path.join(self.opt.resume, 'netD.pth'))['state_dict']) + print("\tDone.\n") + + if self.opt.verbose: + print(self.netg) + print(self.netd) + + ## + # Loss Functions + self.l_adv = nn.BCELoss().npu() + self.l_con = nn.L1Loss().npu() + self.l_lat = l2_loss + + ## + # Initialize input tensors. + self.input = torch_npu.empty_with_format((self.opt.batchsize, 3, self.opt.isize, self.opt.isize), dtype=torch.float32, device=self.device) + self.noise = torch_npu.empty_with_format((self.opt.batchsize, 3, self.opt.isize, self.opt.isize), dtype=torch.float32, device=self.device) + self.label = torch_npu.empty_with_format((self.opt.batchsize,), dtype=torch.float32, device=self.device) + self.gt = torch_npu.empty_with_format((opt.batchsize,), dtype=torch.long, device=self.device) + self.fixed_input = torch_npu.empty_with_format((self.opt.batchsize, 3, self.opt.isize, self.opt.isize), + dtype=torch.float32, device=self.device) + self.real_label = torch.rand(self.opt.batchsize,).npu().one_() + self.fake_label = torch.zeros((self.opt.batchsize,)).npu() + + + ## + # Setup optimizer + if self.opt.isTrain: + self.netg.train() + self.netd.train() + self.optimizers = [] + if self.opt.amp: + self.optimizer_d = NpuFusedAdam(self.netd.parameters(), lr=self.opt.lr, betas=(self.opt.beta1, 0.999)) + self.optimizer_g = NpuFusedAdam(self.netg.parameters(), lr=self.opt.lr, betas=(self.opt.beta1, 0.999)) + self.netd, self.optimizer_d = amp.initialize(self.netd, self.optimizer_d, opt_level=self.opt.opt_level, loss_scale=self.opt.loss_scale) + self.netg, self.optimizer_g = amp.initialize(self.netg, self.optimizer_g, opt_level=self.opt.opt_level, loss_scale=self.opt.loss_scale) + else: + self.optimizer_d = optim.Adam(self.netd.parameters(), lr=self.opt.lr, betas=(self.opt.beta1, 0.999)) + self.optimizer_g = optim.Adam(self.netg.parameters(), lr=self.opt.lr, betas=(self.opt.beta1, 0.999)) + + self.optimizers.append(self.optimizer_d) + self.optimizers.append(self.optimizer_g) + self.schedulers = [get_scheduler(optimizer, opt) for optimizer in self.optimizers] + + def forward(self): + # print("forward") + self.forward_g() + self.forward_d() + # print("forward2") + + def forward_g(self): + """ Forward propagate through netG + """ + # print(self.noise.shape) + # print("forward_g") + self.fake = self.netg(self.input + self.noise) + # print("forward_g2") + + def forward_d(self): + """ Forward propagate through netD wby + """ + self.pred_real, self.feat_real = self.netd(self.input.detach()) + self.pred_fake, self.feat_fake = self.netd(self.fake.detach()) + + def backward_g(self): + """ Backpropagate netg + """ + self.err_g_adv = self.opt.w_adv * self.l_adv(self.pred_fake, self.real_label) + self.err_g_con = self.opt.w_con * self.l_con(self.fake, self.input) + self.err_g_lat = self.opt.w_lat * self.l_lat(self.feat_fake, self.feat_real) + + # self.err_consistency = self.opt.w_lat * self.l_lat(self.feat_fake, self.latent) + # print(self.err_consistency) + + self.err_g = self.err_g_adv + self.err_g_con + self.err_g_lat + if self.opt.amp: + with amp.scale_loss(self.err_g, self.optimizer_g) as scaled_loss: + scaled_loss.backward(retain_graph=True) + else: + self.err_g.backward(retain_graph=True) + + + def backward_d(self): + # Fake + pred_fake, _ = self.netd(self.fake.detach()) + self.err_d_fake = self.l_adv(pred_fake, self.fake_label) + + # Real + # pred_real, feat_real = self.netd(self.input) + self.err_d_real = self.l_adv(self.pred_real, self.real_label) + + # Combine losses. + self.err_d = self.err_d_real + self.err_d_fake + self.err_g_lat + + if self.opt.amp: + with amp.scale_loss(self.err_d, self.optimizer_d) as scaled_loss: + scaled_loss.backward() + else: + self.err_d.backward(retain_graph=True) + + + def update_netg(self): + """ Update Generator Network. + """ + self.optimizer_g.zero_grad() + self.backward_g() + # self.optimizer_g.step() + # self.optimizer_g.step() # 指导反向传播的梯度信息，实际上可以将每一次mini-batch看做是一次训练，一次训练更新一次参数空间 + # scheduler.step() # 更新优化器的学习率的，一般是按照epoch为单位进行更换；放在epoch这个大循环下，每几个epoch更新一次学习率 + + + def update_netd(self): + """ Update Discriminator Network. + """ + self.optimizer_d.zero_grad() + self.backward_d() + # self.optimizer_d.step() + if self.err_d < 1e-5: self.reinit_d() + + ## + def optimize_params(self): + """ Optimize netD and netG networks. + """ + # print("optimize_params") + self.forward() + self.update_netg() + self.update_netd() + # print("optimize_params3") + self.optimizer_g.step() + self.optimizer_d.step() + # print("optimize_params2") + + ## + def test(self, plot_hist=True): + """ Test GANomaly model. + + Args: + data ([type]): Dataloader for the test set + + Raises: + IOError: Model weights not found. + """ + with torch.no_grad(): + # Load the weights of netg and netd. + if self.opt.load_weights: + self.load_weights(is_best=True) + + self.opt.phase = 'test' + + scores = {} + + # Create big error tensor for the test set. + self.an_scores = torch.zeros(size=(len(self.data.valid.dataset),), dtype=torch.float32, device=self.device) + self.gt_labels = torch.zeros(size=(len(self.data.valid.dataset),), dtype=torch.long, device=self.device) + self.features = torch.zeros(size=(len(self.data.valid.dataset), self.opt.nz), dtype=torch.float32, + device=self.device) + + print(" Testing %s" % self.name) + self.times = [] + self.total_steps = 0 + epoch_iter = 0 + for i, data in enumerate(self.data.valid, 0): + self.total_steps += self.opt.batchsize + epoch_iter += self.opt.batchsize + time_i = time.time() + + # Forward - Pass + self.set_input(data) + self.fake = self.netg(self.input) + + _, self.feat_real = self.netd(self.input) + _, self.feat_fake = self.netd(self.fake) + + # Calculate the anomaly score. + si = self.input.size() + sz = self.feat_real.size() + rec = (self.input - self.fake).view(si[0], si[1] * si[2] * si[3]) + # save_rec = np.array(rec.cpu().detach()) + # io.savemat('save_rec.mat', {'save_rec': save_rec}) + lat = (self.feat_real - self.feat_fake).view(sz[0], sz[1] * sz[2] * sz[3]) + rec = torch.mean(torch.pow(rec, 2), dim=1) + lat = torch.mean(torch.pow(lat, 2), dim=1) + error = 0.9 * rec + 0.1 * lat + + time_o = time.time() + + self.an_scores[i * self.opt.batchsize: i * self.opt.batchsize + error.size(0)] = error.reshape( + error.size(0)) + self.gt_labels[i * self.opt.batchsize: i * self.opt.batchsize + error.size(0)] = self.gt.reshape( + error.size(0)) + + self.times.append(time_o - time_i) + + # Save test images. + if self.opt.save_test_images: + dst = os.path.join(self.opt.outf, self.opt.name, 'test', 'images') + if not os.path.isdir(dst): os.makedirs(dst) + real, fake, _ = self.get_current_images() + vutils.save_image(self.input.data, '%s/real_%03d.eps' % (dst, i + 1), normalize=True) + vutils.save_image(self.fake.data, '%s/fake_%03d.eps' % (dst, i + 1), normalize=True) + + # Measure inference time. + self.times = np.array(self.times) + self.times = np.mean(self.times[:100] * 1000) + + # Scale error vector between [0, 1] + self.an_scores = (self.an_scores - torch.min(self.an_scores)) / \ + (torch.max(self.an_scores) - torch.min(self.an_scores)) + auc = roc(self.gt_labels, self.an_scores) + performance = OrderedDict([('Avg Run Time (ms/batch)', self.times), ('AUC', auc)]) + + ## + # PLOT HISTOGRAM + if plot_hist: + plt.ion() + # Create data frame for scores and labels. + scores['scores'] = self.an_scores.cpu() + scores['labels'] = self.gt_labels.cpu() + hist = pd.DataFrame.from_dict(scores) + hist.to_csv("histogram.csv") + + # Filter normal and abnormal scores. + abn_scr = hist.loc[hist.labels == 1]['scores'] + nrm_scr = hist.loc[hist.labels == 0]['scores'] + + # Create figure and plot the distribution. + # fig, ax = plt.subplots(figsize=(4,4)); + sns.histplot(nrm_scr, label=r'Normal Scores') + sns.histplot(abn_scr, label=r'Abnormal Scores') + + plt.legend() + plt.yticks([]) + plt.xlabel(r'Anomaly Scores') + plt.show() + + ## + # PLOT PERFORMANCE + if self.opt.display_id > 0 and self.opt.phase == 'test': + counter_ratio = float(epoch_iter) / len(self.data.valid.dataset) + self.visualizer.plot_performance(self.epoch, counter_ratio, performance) + + ## + # RETURN + return performance diff --git a/best_practices/contrib/ganomaly/lib/models/unet_parts.py b/best_practices/contrib/ganomaly/lib/models/unet_parts.py new file mode 100644 index 0000000000000000000000000000000000000000..559a52fa03735d69a80c88e82fd61ba8377062ce --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/models/unet_parts.py @@ -0,0 +1,217 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .layers import * + + +class DoubleConv(nn.Module): + """(convolution => [BN] => ReLU) * 2""" + + def __init__(self, in_channels, out_channels, mid_channels=None): + super(DoubleConv,self).__init__() + if not mid_channels: + mid_channels = out_channels + self.double_conv = nn.Sequential( + nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1), + nn.BatchNorm2d(mid_channels), + nn.ReLU(inplace=True), + nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1), + nn.BatchNorm2d(out_channels), + nn.ReLU(inplace=True) + ) + + def forward(self, x): + return self.double_conv(x) + + +class Down(nn.Module): + """Downscaling with maxpool then double conv""" + + def __init__(self, in_channels, out_channels): + super(Down,self).__init__() + self.maxpool_conv = nn.Sequential( + nn.MaxPool2d(2), + # SoftPool2d(), + DoubleConv(in_channels, out_channels) + ) + + def forward(self, x): + return self.maxpool_conv(x) + + +class Up(nn.Module): + """Upscaling then double conv""" + + def __init__(self, in_channels, out_channels, bilinear=False): + super(Up,self).__init__() + + # if bilinear, use the normal convolutions to reduce the number of channels + if bilinear: + self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True) + self.conv = DoubleConv(in_channels, out_channels, in_channels // 2) + else: + self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2) + self.conv = DoubleConv(in_channels, out_channels) + + def forward(self, x1, x2): + x1 = self.up(x1) + # input is CHW + diffY = x2.size()[2] - x1.size()[2] + diffX = x2.size()[3] - x1.size()[3] + + x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2, + diffY // 2, diffY - diffY // 2]) + # if you have padding issues, see + x = torch.cat([x2, x1], dim=1) + return self.conv(x) + + +class OutConv(nn.Module): + def __init__(self, in_channels, out_channels): + super(OutConv, self).__init__() + self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1) + + def forward(self, x): + return self.conv(x) + + +# ================================================================== proposed +class DoubleResidualConvSE(nn.Module): + """(convolution => [BN] => ReLU) * 2 + skip_conv""" + + def __init__(self, in_channels, out_channels, mid_channels=None): + super(DoubleResidualConvSE,self).__init__() + if not mid_channels: + mid_channels = out_channels + self.double_conv = nn.Sequential( + nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1), + nn.BatchNorm2d(mid_channels), + nn.ReLU(inplace=True), + + SEBlock(mode="max", channels=mid_channels, reduction_ratio=16), + nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1), + nn.BatchNorm2d(out_channels), + ) + self.skip_conv = nn.Sequential( + nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), + nn.BatchNorm2d(out_channels), + ) + self.relu = nn.ReLU(inplace=True) + + def forward(self, x): + x = self.double_conv(x) + self.skip_conv(x) + return self.relu(x) + + +class DownSE(nn.Module): + """Downscaling with maxpool or softpool, then double conv""" + + def __init__(self, in_channels, out_channels): + super(DownSE,self).__init__() + self.softpool_conv = nn.Sequential( + # nn.MaxPool2d(2), + SoftPool2d(2), + DoubleResidualConvSE(in_channels, out_channels) + ) + + def forward(self, x): + return self.softpool_conv(x) + + +class DownconvBlock_layer1(nn.Module): + """ Msc block (feature(x) from layer 1)""" + def __init__(self, in_channels, out_channels, mid_channels=None, mode="soft"): + super(DownconvBlock_layer1,self).__init__() + if not mid_channels: + mid_channels = out_channels + if mode == "soft": + self.pooling_layer = SoftPool2d(2) + elif mode == "max": + self.pooling_layer = nn.MaxPool2d(2) + + self.double_conv = nn.Sequential( + nn.Conv2d(in_channels, mid_channels, kernel_size=3, stride=2, padding=1), + nn.BatchNorm2d(mid_channels), + nn.ReLU(inplace=True), + SoftPool2d(2), + nn.Conv2d(mid_channels, out_channels, kernel_size=3, stride=2, padding=1), + nn.BatchNorm2d(out_channels), + nn.ReLU(inplace=True), + SoftPool2d(2) + ) + + def forward(self, x): + return self.double_conv(x) + + +class DownconvBlock_layer2(nn.Module): + def __init__(self, in_channels, out_channels, mid_channels=None, mode="soft"): + super(DownconvBlock_layer2,self).__init__() + if not mid_channels: + mid_channels = out_channels + if mode == "soft": + self.pooling_layer = SoftPool2d(2) + elif mode == "max": + self.pooling_layer = nn.MaxPool2d(2) + + self.double_conv = nn.Sequential( + nn.Conv2d(in_channels, mid_channels, kernel_size=3, stride=2, padding=1), + nn.BatchNorm2d(mid_channels), + nn.ReLU(inplace=True), + SoftPool2d(2), + nn.Conv2d(mid_channels, out_channels, kernel_size=3, stride=2, padding=1), + nn.BatchNorm2d(out_channels), + nn.ReLU(inplace=True), + ) + + def forward(self, x): + return self.double_conv(x) + + +class conv1x1(nn.Module): + def __init__(self, in_channels, out_channels, mid_channels=None): + super(conv1x1,self).__init__() + if not mid_channels: + mid_channels = out_channels + self.convblock = nn.Sequential( + nn.Conv2d(in_channels, out_channels, kernel_size=1), + nn.BatchNorm2d(out_channels), + nn.ReLU(inplace=True) + ) + + def forward(self, x): + return self.convblock(x) \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/lib/visualizer.py b/best_practices/contrib/ganomaly/lib/visualizer.py new file mode 100644 index 0000000000000000000000000000000000000000..c7393c4380f590829a3ceca06f21820b2c8411ca --- /dev/null +++ b/best_practices/contrib/ganomaly/lib/visualizer.py @@ -0,0 +1,215 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +import os +import time +import numpy as np +import torchvision.utils as vutils + +class Visualizer(): + """ Visualizer wrapper based on Visdom. + based on Facebook's visdom. + Returns: + Visualizer: Class file. + """ + + ## + def __init__(self, opt): + # self.opt = opt + self.display_id = opt.display_id + self.win_size = 256 + self.name = opt.name + self.opt = opt + if self.opt.display: + import visdom + self.vis = visdom.Visdom(server=opt.display_server, port=opt.display_port) + + # -- + # Dictionaries for plotting data and results. + self.plot_data = None + self.plot_res = None + + # -- + # Path to train and test directories. + self.img_dir = os.path.join(opt.outf, opt.name, 'train', 'images') + self.tst_img_dir = os.path.join(opt.outf, opt.name, 'test', 'images') + if not os.path.exists(self.img_dir): + os.makedirs(self.img_dir) + if not os.path.exists(self.tst_img_dir): + os.makedirs(self.tst_img_dir) + # -- + # Log file. + self.log_name = os.path.join(opt.outf, opt.name, 'loss_log.txt') + # with open(self.log_name, "a") as log_file: + # now = time.strftime("%c") + # log_file.write('================ Training Loss (%s) ================\n' % now) + now = time.strftime("%c") + title = f'================ {now} ================\n' + info = f'{opt.abnormal_class}, {opt.nz}, {opt.w_adv}, {opt.w_con}, {opt.w_lat}\n' + self.write_to_log_file(text=title + info) + + + ## + @staticmethod + def normalize(inp): + """Normalize the tensor + + Args: + inp ([FloatTensor]): Input tensor + + Returns: + [FloatTensor]: Normalized tensor. + """ + return (inp - inp.min()) / (inp.max() - inp.min() + 1e-5) + + ## + def plot_current_errors(self, epoch, counter_ratio, errors): + """Plot current errros. + + Args: + epoch (int): Current epoch + counter_ratio (float): Ratio to plot the range between two epoch. + errors (OrderedDict): Error for the current epoch. + """ + + if not hasattr(self, 'plot_data') or self.plot_data is None: + self.plot_data = {'X': [], 'Y': [], 'legend': list(errors.keys())} + self.plot_data['X'].append(epoch + counter_ratio) + self.plot_data['Y'].append([errors[k] for k in self.plot_data['legend']]) + self.vis.line( + X=np.stack([np.array(self.plot_data['X'])] * len(self.plot_data['legend']), 1), + Y=np.array(self.plot_data['Y']), + opts={ + 'title': self.name + ' loss over time', + 'legend': self.plot_data['legend'], + 'xlabel': 'Epoch', + 'ylabel': 'Loss' + }, + win=4 + ) + + ## + def plot_performance(self, epoch, counter_ratio, performance): + """ Plot performance + + Args: + epoch (int): Current epoch + counter_ratio (float): Ratio to plot the range between two epoch. + performance (OrderedDict): Performance for the current epoch. + """ + if not hasattr(self, 'plot_res') or self.plot_res is None: + self.plot_res = {'X': [], 'Y': [], 'legend': list(performance.keys())} + self.plot_res['X'].append(epoch + counter_ratio) + self.plot_res['Y'].append([performance[k] for k in self.plot_res['legend']]) + self.vis.line( + X=np.stack([np.array(self.plot_res['X'])] * len(self.plot_res['legend']), 1), + Y=np.array(self.plot_res['Y']), + opts={ + 'title': self.name + 'Performance Metrics', + 'legend': self.plot_res['legend'], + 'xlabel': 'Epoch', + 'ylabel': 'Stats' + }, + win=5 + ) + + ## + def print_current_errors(self, epoch, errors): + """ Print current errors. + + Args: + epoch (int): Current epoch. + errors (OrderedDict): Error for the current epoch. + batch_i (int): Current batch + batch_n (int): Total Number of batches. + """ + # message = ' [%d/%d] ' % (epoch, self.opt.niter) + message = ' Loss: [%d/%d] ' % (epoch, self.opt.niter) + for key, val in errors.items(): + message += '%s: %.3f ' % (key, val) + + print(message) + with open(self.log_name, "a") as log_file: + log_file.write('%s\n' % message) + + ## + def write_to_log_file(self, text): + with open(self.log_name, "a") as log_file: + log_file.write('%s\n' % text) + + ## + def print_current_performance(self, performance, best): + """ Print current performance results. + + Args: + performance ([OrderedDict]): Performance of the model + best ([int]): Best performance. + """ + message = ' ' + for key, val in performance.items(): + message += '%s: %.3f ' % (key, val) + message += 'max AUC: %.3f' % best + + print(message) + self.write_to_log_file(text=message) + + def display_current_images(self, reals, fakes, fixed): + """ Display current images. + + Args: + epoch (int): Current epoch + counter_ratio (float): Ratio to plot the range between two epoch. + reals ([FloatTensor]): Real Image + fakes ([FloatTensor]): Fake Image + fixed ([FloatTensor]): Fixed Fake Image + """ + reals = self.normalize(reals.cpu().numpy()) + fakes = self.normalize(fakes.cpu().numpy()) + # fixed = self.normalize(fixed.cpu().numpy()) + + self.vis.images(reals, win=1, opts={'title': 'Reals'}) + self.vis.images(fakes, win=2, opts={'title': 'Fakes'}) + # self.vis.images(fixed, win=3, opts={'title': 'Fixed'}) + + def save_current_images(self, epoch, reals, fakes, fixed): + """ Save images for epoch i. + + Args: + epoch ([int]) : Current epoch + reals ([FloatTensor]): Real Image + fakes ([FloatTensor]): Fake Image + fixed ([FloatTensor]): Fixed Fake Image + """ + vutils.save_image(reals, '%s/reals.png' % self.img_dir, normalize=True) + vutils.save_image(fakes, '%s/fakes.png' % self.img_dir, normalize=True) + vutils.save_image(fixed, '%s/fixed_fakes_%03d.png' %(self.img_dir, epoch+1), normalize=True) diff --git a/best_practices/contrib/ganomaly/options.py b/best_practices/contrib/ganomaly/options.py new file mode 100644 index 0000000000000000000000000000000000000000..90d4ccf46b33543bb3d4f160ee6c118cff982551 --- /dev/null +++ b/best_practices/contrib/ganomaly/options.py @@ -0,0 +1,186 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +import argparse +import os +import torch + + +class Options(): + """Options class + largely based on junyanz/pytorch-CycleGAN-and-pix2pix. + Returns: + [argparse]: argparse containing train and test options + """ + + def __init__(self): + ## + # + self.parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter) + + ## + # Base + self.parser.add_argument('--dataset', default='Mainboard', help='Mainboard/mvtec-cable| folder | cifar10 | mnist | Mainboard') + self.parser.add_argument('--dataroot', default='', help='path to dataset') + self.parser.add_argument('--path', default='', help='data/Mainboard, path to the folder or image to be predicted.') + self.parser.add_argument('--batchsize', type=int, default=128, help='input batch size') + self.parser.add_argument('--workers', type=int, help='number of data loading workers', default=8) + self.parser.add_argument('--droplast', action='store_true', default=True, help='Drop last batch size.') + self.parser.add_argument('--isize', type=int, default=32, help='cifar10 is 256 | input image size.') + self.parser.add_argument('--nc', type=int, default=3, help='input image channels') + self.parser.add_argument('--nz', type=int, default=100, help='size of the latent z vector') + self.parser.add_argument('--ngf', type=int, default=64) + self.parser.add_argument('--ndf', type=int, default=64) + self.parser.add_argument('--extralayers', type=int, default=0, help='Number of extra layers on gen and disc') + # self.parser.add_argument('--device', type=str, default='gpu', help='Device: gpu | cpu') + self.parser.add_argument('--gpu_ids', type=str, default='0', help='gpu ids: e.g. 0 0,1,2, 0,2. use -1 for CPU') + self.parser.add_argument('--ngpu', type=int, default=1, help='number of GPUs to use') + self.parser.add_argument('--name', type=str, default='experiment_name', help='name of the experiment') + self.parser.add_argument('--model', type=str, default='skipganomaly', + help='chooses which model to use. skipganomaly') + self.parser.add_argument('--display_server', type=str, default="http://localhost", + help='visdom server of the web display') + self.parser.add_argument('--display_port', type=int, default=8097, help='visdom port of the web display') + self.parser.add_argument('--display_id', type=int, default=0, help='window id of the web display') + self.parser.add_argument('--display', action='store_true', help='Use visdom.') + self.parser.add_argument('--verbose', action='store_true', help='Print the training and model details.') + self.parser.add_argument('--outf', default='./output', help='folder to output images and model checkpoints') + self.parser.add_argument('--manualseed', default= 1, type=int, help='manual seed') + self.parser.add_argument('--abnormal_class', default='', help='cat | Anomaly class idx for mnist and cifar datasets') + self.parser.add_argument('--metric', type=str, default='roc', help='Evaluation metric.') + + ## + # Train + self.parser.add_argument('--print_freq', type=int, default=100, + help='frequency of showing training results on console') + self.parser.add_argument('--save_image_freq', type=int, default=100, + help='frequency of saving real and fake images') + self.parser.add_argument('--save_test_images', default='true', action='store_true', + help='Save test images for demo.') + self.parser.add_argument('--load_weights', action='store_true', help='Load the pretrained weights') + self.parser.add_argument('--resume', default='', help="path to checkpoints (to continue training)") + self.parser.add_argument('--phase', type=str, default='train', help='train, val, test, etc') + self.parser.add_argument('--iter', type=int, default=0, help='Start from iteration i') + self.parser.add_argument('--niter', type=int, default=15, help='number of epochs to train for') + self.parser.add_argument('--niter_decay', type=int, default=100, + help='# of iter to linearly decay learning rate to zero') + self.parser.add_argument('--beta1', type=float, default=0.5, help='momentum term of adam') + self.parser.add_argument('--lr', type=float, default=0.0002, help='initial learning rate for adam') + self.parser.add_argument('--w_adv', type=float, default=1, help='Weight for adversarial loss. default=1') + self.parser.add_argument('--w_con', type=float, default=50, help='Weight for reconstruction loss. default=50') + self.parser.add_argument('--w_lat', type=float, default=1, help='Weight for latent space loss. default=1') + self.parser.add_argument('--lr_policy', type=str, default='lambda', help='lambda|step|plateau') + self.parser.add_argument('--lr_decay_iters', type=int, default=50, + help='multiply by a gamma every lr_decay_iters iterations') + + ## add useful parameters : such as resume,evaluate + self.parser.add_argument('--checkpoint-path', default=None, type=str, metavar='PATH', + help='path to latest checkpoint (default: none)') + self.parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true', default=False, + help='evaluate model : generate (n_samples) samples,saved in dir(validate)') + self.parser.add_argument('--n-samples', type=int, default=10, + help="amount of samples in function(validate)") + self.parser.add_argument('-p', '--print-freq', default=10, type=int, metavar='N', + help='print frequency (default 10)') + + ## parameters for distribute training + self.parser.add_argument('--world-size', default=-1, type=int, + help='number of nodes for distributed training') + self.parser.add_argument('--rank', default=-1, type=int, + help='node rank for distributed training') + self.parser.add_argument('--dist-url', default='tcp://224.66.41.62:23456', type=str, + help='url used to set up distributed training') + self.parser.add_argument('--dist-backend', default='nccl', type=str, + help='distributed backend') + self.parser.add_argument('--gpu', default=None, type=int, + help='GPU id to use.') + + ## for ascend 910 + self.parser.add_argument('--device', default='npu', type=str, help='npu or gpu') + self.parser.add_argument('--addr', default='10.136.181.115', + type=str, help='master addr') + self.parser.add_argument('--device-list', default='0,1,2,3,4,5,6,7', + type=str, help='device id list') + self.parser.add_argument('--amp', default=False, action='store_true', + help='use amp to train the model') + self.parser.add_argument('--loss-scale', default=128, type=float, + help='loss scale using in amp, default None means dynamic') + self.parser.add_argument('--opt-level', default='O2', type=str, + help='loss scale using in amp, default -1 means dynamic') + self.parser.add_argument('--prof', default=False, action='store_true', + help='use profiling to evaluate the performance of model') + + self.isTrain = True + self.opt = None + + def parse(self): + """ Parse Arguments. + """ + + self.opt = self.parser.parse_args() + self.opt.isTrain = self.isTrain # train or test + + # get gpu ids + str_ids = self.opt.gpu_ids.split(',') + self.opt.gpu_ids = [] + for str_id in str_ids: + id = int(str_id) + if id >= 0: + self.opt.gpu_ids.append(id) + + args = vars(self.opt) + + if self.opt.verbose: + print('------------ Options -------------') + for k, v in sorted(args.items()): + print('%s: %s' % (str(k), str(v))) + print('-------------- End ----------------') + + # save to the disk + if self.opt.name == 'experiment_name': + self.opt.name = "%s/%s" % (self.opt.model, self.opt.dataset) + expr_dir = os.path.join(self.opt.outf, self.opt.name, 'train') + test_dir = os.path.join(self.opt.outf, self.opt.name, 'test') + + if not os.path.isdir(expr_dir): + os.makedirs(expr_dir) + if not os.path.isdir(test_dir): + os.makedirs(test_dir) + + file_name = os.path.join(expr_dir, 'opt.txt') + with open(file_name, 'wt') as opt_file: + opt_file.write('------------ Options -------------\n') + for k, v in sorted(args.items()): + opt_file.write('%s: %s\n' % (str(k), str(v))) + opt_file.write('-------------- End ----------------\n') + return self.opt diff --git a/best_practices/contrib/ganomaly/requirements.txt b/best_practices/contrib/ganomaly/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..eff470746e37959221dfedd6cd2f1dfdcbadee5b --- /dev/null +++ b/best_practices/contrib/ganomaly/requirements.txt @@ -0,0 +1,50 @@ +asn1crypto==0.24.0 +backcall==0.1.0 +certifi==2019.6.16 +cffi==1.12.3 +chardet==3.0.4 +cryptography==2.7 +cycler==0.10.0 +decorator==4.4.0 +idna==2.8 +imageio==2.5.0 +ipython==7.7.0 +ipython-genutils==0.2.0 +jedi==0.15.0 +joblib==0.13.2 +kiwisolver==1.1.0 +matplotlib==3.1.0 +numpy==1.16.4 +olefile==0.46 +pandas==0.25.0 +parso==0.5.1 +patsy==0.5.1 +pexpect==4.7.0 +pickleshare==0.7.5 +Pillow>=6.2.0 +prompt-toolkit==2.0.9 +ptyprocess==0.6.0 +pycparser==2.19 +Pygments==2.4.2 +pyOpenSSL==19.0.0 +pyparsing==2.4.0 +PySocks==1.7.0 +python-dateutil==2.8.0 +pytz==2019.1 +pyzmq==18.0.2 +requests==2.22.0 +scikit-learn==0.21.2 +scipy==1.3.0 +seaborn==0.9.0 +six==1.12.0 +statsmodels==0.10.1 +torch==1.8.1 +torchfile==0.1.0 +torchvision==0.4.0 +tornado==6.0.3 +tqdm==4.33.0 +traitlets==4.3.2 +urllib3==1.25.3 +visdom==0.1.8.8 +wcwidth==0.1.7 +websocket-client==0.56.0 \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/test.py b/best_practices/contrib/ganomaly/test.py new file mode 100644 index 0000000000000000000000000000000000000000..5a2cb77ccd22141155fdf0aa00579ee63d7a989d --- /dev/null +++ b/best_practices/contrib/ganomaly/test.py @@ -0,0 +1,115 @@ +import sys +sys.path.append("../") +import os +import torch +import numpy as np +import acl +import cv2 as cv +from PIL import Image +import constants as const +from acllite_model import AclLiteModel +from acllite_resource import AclLiteResource + +INPUT_DIR = '../test/' +OUTPUT_DIR = '../out/' +MODEL_PATH_G = "../model/g.om" +MODEL_PATH_D = "../model/d.om" + + + + +MODEL_WIDTH = 608 +MODEL_HEIGHT = 608 +class_num = 80 +stride_list = [32, 16, 8] +anchors_3 = np.array([[12, 16], [19, 36], [40, 28]]) / stride_list[2] +anchors_2 = np.array([[36, 75], [76, 55], [72, 146]]) / stride_list[1] +anchors_1 = np.array([[142, 110], [192, 243], [459, 401]]) / stride_list[0] +anchor_list = [anchors_1, anchors_2, anchors_3] +iou_threshold = 0.3 +colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (0, 255, 255), (255, 0, 255), (255, 255, 0)] + +def preprocess(img_path): + image = Image.open(img_path) + img_h = image.size[1] + img_w = image.size[0] + net_h = MODEL_HEIGHT + net_w = MODEL_WIDTH + + scale = min(float(net_w) / float(img_w), float(net_h) / float(img_h)) + new_w = int(img_w * scale) + new_h = int(img_h * scale) + + shift_x = (net_w - new_w) // 2 + shift_y = (net_h - new_h) // 2 + shift_x_ratio = (net_w - new_w) / 2.0 / net_w + shift_y_ratio = (net_h - new_h) / 2.0 / net_h + + image_ = image.resize((new_w, new_h)) + new_image = np.zeros((net_h, net_w, 3), np.uint8) + new_image[shift_y: new_h + shift_y, shift_x: new_w + shift_x, :] = np.array(image_) + new_image = new_image.astype(np.float32) + new_image = new_image / 255 + print('new_image.shape', new_image.shape) + new_image = new_image.transpose(2, 0, 1).copy() + return new_image, image + +def main(): + # set torch + device = 'npu:{}'.format(0) + torch.npu.set_device(device) + + if not os.path.exists(OUTPUT_DIR): + os.mkdir(OUTPUT_DIR) + #ACL resource initialization + acl_resource = AclLiteResource() + acl_resource.init() + #load model + netg = AclLiteModel(MODEL_PATH_G) + netd = AclLiteModel(MODEL_PATH_D) + + images_list = [os.path.join(INPUT_DIR, img) + for img in os.listdir(INPUT_DIR) + if os.path.splitext(img)[1] in const.IMG_EXT] + + # Create big error tensor for the test set. + an_scores = torch.zeros(size=(len(images_list),), dtype=torch.float32, device=device) + gt_labels = torch.zeros(size=(len(images_list),), dtype=torch.long, device=device) + features = torch.zeros(size=(len(images_list), 100), dtype=torch.float32,device=device) + images_list = [os.path.join(INPUT_DIR, img) + for img in os.listdir(INPUT_DIR) + if os.path.splitext(img)[1] in const.IMG_EXT] + + total_steps = 0 + #Read images from the data directory one by one for reasoning + for pic in images_list: + #read image + bgr_img = cv.imread(pic) + #preprocess + data, orig = preprocess(pic) + #Send into model inference + fake = netg.execute([data,]) + _, feat_real = netd.execute([data,]) + _, feat_fake = netd.execute([fake,]) + # Calculate the anomaly score. + si = data.size() + sz = feat_real.size() + rec = (data - fake).view(si[0] * si[1] * si[2]) + # save_rec = np.array(rec.cpu().detach()) + # io.savemat('save_rec.mat', {'save_rec': save_rec}) + lat = (feat_real - feat_fake).view(si[0] * si[1] * si[2]) + rec = torch.mean(torch.pow(rec, 2), dim=0) + lat = torch.mean(torch.pow(lat, 2), dim=0) + error = 0.9 * rec + 0.1 * lat + + an_scores[total_steps: total_steps+1] = error + total_steps = total_steps + 1 + + output_file = os.path.join(OUTPUT_DIR, "out_" + str(error) + os.path.basename(pic)) + cv.imwrite(output_file, data) + # an_scores = (an_scores - torch.min(an_scores)) / \ + # (torch.max(an_scores) - torch.min(an_scores)) + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/test_npu_1p.py b/best_practices/contrib/ganomaly/test_npu_1p.py new file mode 100644 index 0000000000000000000000000000000000000000..dc4287ab198c00cbd2bcd6c663049866ad43ef0f --- /dev/null +++ b/best_practices/contrib/ganomaly/test_npu_1p.py @@ -0,0 +1,122 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +import argparse +import os +import time +import apex +from apex import amp +import datetime +from lib.data.dataloader import load_data + +import torch +import torch.nn as nn +import torch.nn.parallel +import torch.backends.cudnn as cudnn +import torch.distributed as dist +import torch.optim +import torch.utils.data +import torch.utils.data.distributed + +import torchvision.transforms as transforms +import torchvision.datasets as datasets +from torchvision.utils import save_image + +from lib.data.dataloader import load_data +from lib.models import load_model +from options import Options + + +def device_id_to_process_device_map(device_list): + devices = device_list.split(",") + devices = [int(x) for x in devices] + devices.sort() + + process_device_map = dict() + for process_id, device_id in enumerate(devices): + process_device_map[process_id] = device_id + + return process_device_map + + +def get_device_name(device_type, device_order): + if device_type == 'npu': + device_name = 'npu:{}'.format(device_order) + else: + device_name = 'cuda:{}'.format(device_order) + + return device_name + + +def main(): + args = Options().parse() + + os.environ['MASTER_ADDR'] = args.addr # 获取有关系统的各种信息，获取环境变量 + os.environ['MASTER_PORT'] = '29688' + + if args.device == 'npu': + ngpus_per_node = 1 + else: + if args.gpu is None: + ngpus_per_node = 1 + else: + ngpus_per_node = 1 + print(f'ngpus_per_node:{ngpus_per_node}, and enter into main_worker()') + + main_worker(args) + +def main_worker(args): + args.gpu = 0 + device = get_device_name(args.device, args.gpu) + args.loc = device + # set device + ############## npu modify begin ############# + print("set_device", device) + if args.device == "npu": + torch.npu.set_device(device) # 声明当前使用的设备 + else: + torch.cuda.set_device(args.gpu) + ############## npu modify begin ############# + + data = load_data(args) + model = load_model(args, data) + # print(model) # 创建model，默认是torch.FloatTensor + print('装载') + model.load_weights(is_best = True) + print('测试') + model.test() + # print('训练') + # model.train() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/best_practices/contrib/ganomaly/train_npu_1p.py b/best_practices/contrib/ganomaly/train_npu_1p.py new file mode 100644 index 0000000000000000000000000000000000000000..e5ba3249149f9211264dbe5ef35e6e4c3e4eea1d --- /dev/null +++ b/best_practices/contrib/ganomaly/train_npu_1p.py @@ -0,0 +1,118 @@ +# +# BSD 3-Clause License +# +# Copyright (c) 2017 xxxx +# All rights reserved. +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# * Neither the name of the copyright holder nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# ============================================================================ +# +import argparse +import os +import time +import apex +from apex import amp +import datetime +from lib.data.dataloader import load_data + +import torch +import torch.nn as nn +import torch.nn.parallel +import torch.backends.cudnn as cudnn +import torch.distributed as dist +import torch.optim +import torch.utils.data +import torch.utils.data.distributed + +import torchvision.transforms as transforms +import torchvision.datasets as datasets +from torchvision.utils import save_image + +from lib.data.dataloader import load_data +from lib.models import load_model +from options import Options + + +def device_id_to_process_device_map(device_list): + devices = device_list.split(",") + devices = [int(x) for x in devices] + devices.sort() + + process_device_map = dict() + for process_id, device_id in enumerate(devices): + process_device_map[process_id] = device_id + + return process_device_map + + +def get_device_name(device_type, device_order): + if device_type == 'npu': + device_name = 'npu:{}'.format(device_order) + else: + device_name = 'cuda:{}'.format(device_order) + + return device_name + + +def main(): + args = Options().parse() + + os.environ['MASTER_ADDR'] = args.addr # 获取有关系统的各种信息，获取环境变量 + os.environ['MASTER_PORT'] = '29688' + + if args.device == 'npu': + ngpus_per_node = 1 + else: + if args.gpu is None: + ngpus_per_node = 1 + else: + ngpus_per_node = 1 + print(f'ngpus_per_node:{ngpus_per_node}, and enter into main_worker()') + + main_worker(args) + +def main_worker(args): + args.gpu = 0 + device = get_device_name(args.device, args.gpu) + args.loc = device + # set device + ############## npu modify begin ############# + print("set_device", device) + if args.device == "npu": + torch.npu.set_device(device) # 声明当前使用的设备 + else: + torch.cuda.set_device(args.gpu) + ############## npu modify begin ############# + + data = load_data(args) + model = load_model(args, data) + # print(model) # 创建model，默认是torch.FloatTensor + print('训练') + model.train() + +if __name__ == '__main__': + main() \ No newline at end of file