My Journey in Six Sigma, Lean, Data Science

How To Read And Convert XML Table To DataFrame

noreply@blogger.com (I Talk - You Do) — Sat, 24 Sep 2022 04:44:00 +0000

code 到用时方恨少。之前就有想过把工作上某个 copy paste 的程式自动化，但都没有去执行。主要原因还是因为一直以来都是我自己在做，copy paste 嘛，原本就是一件很简单不过的事情，几秒钟的时间就能完成。但是，当我把这份简单的工作传给其他人来做的时后，我开始发现，原来，这 copy paste 的动作，对其他人来说并不那么容易掌控，错误百出，搞到自己接到不少的投诉。

有些人就是这样，一个简单的动作都不能做好，也不问问自己身体哪方面出了问题，尽会投诉。既然那么会投诉，但从来不投诉自己为啥那么残。

没办法，我唯一能做的就是把这我看似简单不过的动作再进一步自动化。这一个小小的投诉，又让我前进一小步。

以下是我再 stackoverflow 趴回来的 code，已试过。没问题。

# function to convert refx.xml to dataframe
# https://stackoverflow.com/questions/53317592/reading-pascal-voc-annotations-in-python
def read_content(xml_file: str):


    tree = ET.parse(xml_file)
    root = tree.getroot()

    list_with_all_boxes = []

    for boxes in root.iter('object'):

        filename = root.find('filename').text

        ymin, xmin, ymax, xmax = None, None, None, None

        ymin = int(boxes.find("bndbox/ymin").text)
        xmin = int(boxes.find("bndbox/xmin").text)
        ymax = int(boxes.find("bndbox/ymax").text)
        xmax = int(boxes.find("bndbox/xmax").text)

        list_with_single_boxes = [xmin, ymin, xmax, ymax]
        list_with_all_boxes.append(list_with_single_boxes)
        
    return filename, list_with_all_boxes

过后把这 code 发给了另外一个同事，她帮我修改了一下，还没经过测试。从 code 的流程来看，应该没什么问题。anyway，先把它给收藏好。

#code from ayuni

def read_xml(path):
    obj_list = []
    tree = ET.parse(open(path,'r'))
    root = tree.getroot()
    for objects in root.findall('object'):
        name = objects.find('name').text
        bndbox = objects.find('bndbox')
        xmin = int(bndbox.find('xmin').text)
        ymin = int(bndbox.find('ymin').text)
        xmax = int(bndbox.find('xmax').text)
        ymax = int(bndbox.find('ymax').text)
        class_name = objects.find('name').text
        obj_list.append({'class':class_name, 'bbox':{'x1': xmin, 'x2': xmax, 'y1':ymin, 'y2':ymax }})
    
    return obj_list

How To Load Yolov5 Custom Object Detection Model For Inferencing

noreply@blogger.com (I Talk - You Do) — Tue, 24 May 2022 15:22:00 +0000

之前的 post，我用了 Roboflow 的 detect.py script 来做 inferencing，这个 script 基本上没什么问题，问题是他们的 script 只是把 detect 到的 object 用 bounding box frame 起来，然后 save 在一个 location。就这样完事。但没有我要的 inferencing data。那天花了我半天的时间尝试在 detect.py 加上自己的 script，的确是可以把 inferencing data 给 show 出来，但是就是无法把那些 data 收进一个 dataframe。

幸好，在网上给我趴到另外一个比较简单的 inferencing 方法（link 又弄丢了）。Anyway，最重要的还是 code 没问题。

以下是 yolov5 的步骤：

1。第一件事就是把 Google Drive 的 folder 联上，和 import 需要用到的 package

# how to load trained yolov5 custom object detection model weight 
# ref : https://github.com/pylabel-project/samples/blob/main/pylabeler.ipynb


# import required pkg
import os
import torch
import pandas
from google.colab import drive

# mount google drive 
drive.mount('/content/drive')
os.chdir('/content/drive/My Drive/yolov5')

2。设定好 weight, image 和其他的 parameter。（model_iou 是什么来的？）

# defind weight and image location 
# define model_conf and model_iou parameter 

model_path = '/content/drive/My Drive/yolov5/yolov5/runs/train/exp2/weights/best.pt'
imgs = '/content/drive/My Drive/yolov5/test/images/test1.jpg'
model_conf = 0.85 #@param {type:"slider", min:0, max:1, step:0.01}
model_iou = 0.5 #@param {type:"slider", min:0, max:1, step:0.01}
img_size = 416

3。把 model load 出来

# load the model 
model = torch.hub.load('ultralytics/yolov5', 'custom', path=model_path, force_reload=False)

Using cache found in /root/.cache/torch/hub/ultralytics_yolov5_master
YOLOv5 🚀 2022-5-24 Python-3.7.13 torch-1.11.0+cu113 CUDA:0 (Tesla T4, 15110MiB)

Fusing layers... 
Model summary: 213 layers, 7018216 parameters, 0 gradients
Adding AutoShape...

4。开始做 inference

# start inferencing 
model.conf = model_conf
model.iou = model_iou

result = model(imgs, size = img_size)

5。把 inference result print 出来看看

# print out the result 
result.print()

image 1/1: 416x416 2 RBCs
Speed: 15.2ms pre-process, 56.1ms inference, 1.7ms NMS per image at shape (1, 3, 416, 416)

6。最后，把 inference data 弄出来 (这才是重要的 data，有了这些 data，接下来要做什么都行）

# print out tensor
result.xyxy[0]

tensor([[178.00841, 160.75742, 219.08293, 290.41403,   0.89994,   1.00000],
        [ 36.04726, 184.86021,  78.96355, 306.03784,   0.87737,   1.00000]], device='cuda:0')

7。最后把 tensor data 转换成 pandas dataframe。就这样完成。

# convert result into Pandas dataframe
pred_score = result.pandas().xyxy[0]
pred_score


xmin ymin xmax ymax confidence class name
0 178.008408 160.757416 219.082932 290.414032 0.899943 1 RBC
1 36.047264 184.860214 78.963554 306.037842 0.877368 1 RBC

xmin	ymin	xmax	ymax	confidence	class	name
0	178.008408	160.757416	219.082932	290.414032	0.899943	1	RBC
1	36.047264	184.860214	78.963554	306.037842	0.877368	1	RBC

总算掌握了 Yolov5 custom object detection model training, data labling 和 inferencing 的过程。

How To Build Custom Object Detection Model With YoloV5

noreply@blogger.com (I Talk - You Do) — Sat, 21 May 2022 06:14:00 +0000

在上一个 post 我分享用 Roboflow 来准备 YoloV5 的 dataset 格式。也提过其实我们也可以利用 Roboflow 所提供的 training script 来做 YoloV5 的 model training。的确是很方便，但如果你把 dataset 转移到其他 drive 的时候，Roboflow 的 script 就用不着了。所以，今天我还是得记录一下我自己写出来的 training script。好让我日后有个参考。

1。首先，在 Google Drive 开个新的 Folder ，然后把 data set upload 上去。（我们只是 upload train, test, valid dataset 上去 Google Drive，其他两个 folder ，run 和 yolov5 其实是跑 script 的时候从 github 那里 download 下来的 system files。其他的 files 也是一样。

2。可以在 Google Colab 开干了。第一件事就是把 Google Drive 的 folder 联上。

# mount google drive 

import os
from google.colab import drive

drive.mount('/content/drive')
os.chdir('/content/drive/My Drive/yolov5')

#clone YOLOv5 - this is for 1st time insallation, can skip this step after 
# 1st installation
!git clone https://github.com/ultralytics/yolov5  # clone repo
%cd yolov5
%pip install -qr requirements.txt # install dependencies
%pip install -q roboflow

3。这里我们可以检查一下每个 folder 里图片的数量

# check images qty in each folder
from IPython.display import Image, clear_output  # to display images
print('total images found in train folder = ' , len(os.listdir('/content/drive/My Drive/yolov5/train/images')))
print('total images found in test folder = ' , len(os.listdir('/content/drive/My Drive/yolov5/test/images')))
print('total images found in valid folder = ' , len(os.listdir('/content/drive/My Drive/yolov5/valid/images')))

total images found in train folder =  1827
total images found in test folder =  87
total images found in valid folder =  175

4。setup 需要的 environment

# set up environment
os.environ["DATASET_DIRECTORY"] = "/content/drive/My Drive/yolov5"

# ptint content in yaml file 
# nc = number of class
%cat data.yaml

train: ../train/images
val: ../valid/images

nc: 3
names: ['Platelets', 'RBC', 'WBC']

5。可以开始做 model training 了，就这么简单。这里要注意的是那几个重要的 arguement，我们可以根据需要开调整那些 parameter。另外一个需要注意的就是 image size，这个 parameter 需要根据 training dataset 图片而调整。

启动了 training script 之后，就可以看到其他的 hyper parameter，如果需要调整那些 hyper parameter 的话，那么我们需要打开 train.py 的 file 来调整里面的 hyperparameter。Anyway，在大部分的情况都不需要调整的.

# required arguments
# img: define input image size
# batch: determine batch size
# epochs: define the number of training epochs. (Note: often, 3000+ are common here!)
# data: Our dataset locaiton is saved in the dataset.location
# weights: specify a path to weights to start transfer learning from. Here we choose the generic COCO pretrained checkpoint.
# cache: cache images for faster training

# model training command
!python "/content/drive/My Drive/yolov5/yolov5/train.py" --img 416 --batch 16 --epochs 150 --data "/content/drive/My Drive/yolov5/yolov5/data.yaml" --weights yolov5s.pt --cache

ttrain: weights=yolov5s.pt, cfg=, data=/content/drive/My Drive/yolov5/yolov5/data.yaml, hyp=data/hyps/hyp.scratch-low.yaml, epochs=150, batch_size=16, imgsz=416, rect=False, resume=False, nosave=False, noval=False, noautoanchor=False, noplots=False, evolve=None, bucket=, cache=ram, image_weights=False, device=, multi_scale=False, single_cls=False, optimizer=SGD, sync_bn=False, workers=8, project=runs/train, name=exp, exist_ok=False, quad=False, cos_lr=False, label_smoothing=0.0, patience=100, freeze=[0], save_period=-1, local_rank=-1, entity=None, upload_dataset=False, bbox_interval=-1, artifact_alias=latest
Command 'git fetch && git config --get remote.origin.url' timed out after 5 seconds
fatal: cannot change to '/content/drive/My': No such file or directory
YOLOv5 🚀 2022-4-30 torch 1.11.0+cu113 CUDA:0 (Tesla T4, 15110MiB)

hyperparameters: lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=0.05, cls=0.5, cls_pw=1.0, obj=1.0, obj_pw=1.0, iou_t=0.2, anchor_t=4.0, fl_gamma=0.0, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, mosaic=1.0, mixup=0.0, copy_paste=0.0
Weights & Biases: run 'pip install wandb' to automatically track and visualize YOLOv5 🚀 runs (RECOMMENDED)
TensorBoard: Start with 'tensorboard --logdir runs/train', view at http://localhost:6006/
Downloading https://ultralytics.com/assets/Arial.ttf to /root/.config/Ultralytics/Arial.ttf...
100% 755k/755k [00:00<00:00, 124MB/s]
Overriding model.yaml nc=80 with nc=3

                 from  n    params  module                                  arguments                     
  0                -1  1      3520  models.common.Conv                      [3, 32, 6, 2, 2]              
  1                -1  1     18560  models.common.Conv                      [32, 64, 3, 2]                
  2                -1  1     18816  models.common.C3                        [64, 64, 1]                   
  3                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
  4                -1  2    115712  models.common.C3                        [128, 128, 2]                 
  5                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]              
  6                -1  3    625152  models.common.C3                        [256, 256, 3]                 
  7                -1  1   1180672  models.common.Conv                      [256, 512, 3, 2]              
  8                -1  1   1182720  models.common.C3                        [512, 512, 1]                 
  9                -1  1    656896  models.common.SPPF                      [512, 512, 5]                 
 10                -1  1    131584  models.common.Conv                      [512, 256, 1, 1]              
 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 12           [-1, 6]  1         0  models.common.Concat                    [1]                           
 13                -1  1    361984  models.common.C3                        [512, 256, 1, False]          
 14                -1  1     33024  models.common.Conv                      [256, 128, 1, 1]              
 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 16           [-1, 4]  1         0  models.common.Concat                    [1]                           
 17                -1  1     90880  models.common.C3                        [256, 128, 1, False]          
 18                -1  1    147712  models.common.Conv                      [128, 128, 3, 2]              
 19          [-1, 14]  1         0  models.common.Concat                    [1]                           
 20                -1  1    296448  models.common.C3                        [256, 256, 1, False]          
 21                -1  1    590336  models.common.Conv                      [256, 256, 3, 2]              
 22          [-1, 10]  1         0  models.common.Concat                    [1]                           
 23                -1  1   1182720  models.common.C3                        [512, 512, 1, False]          
 24      [17, 20, 23]  1     21576  models.yolo.Detect                      [3, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [128, 256, 512]]
Model summary: 270 layers, 7027720 parameters, 7027720 gradients, 15.9 GFLOPs

Transferred 343/349 items from yolov5s.pt
Scaled weight_decay = 0.0005
optimizer: SGD with parameter groups 57 weight (no decay), 60 weight, 60 bias
albumentations: version 1.0.3 required by YOLOv5, but version 0.1.12 is currently installed
train: Scanning '/content/drive/My Drive/yolov5/yolov5/../train/labels.cache' images and labels... 1827 found, 0 missing, 0 empty, 0 corrupt: 100% 1827/1827 [00:00<?, ?it/s]
train: Caching images (0.9GB ram): 100% 1827/1827 [00:20<00:00, 89.92it/s] 
val: Scanning '/content/drive/My Drive/yolov5/yolov5/../valid/labels.cache' images and labels... 175 found, 0 missing, 0 empty, 0 corrupt: 100% 175/175 [00:00<?, ?it/s]
val: Caching images (0.1GB ram): 100% 175/175 [00:01<00:00, 120.25it/s]
Plotting labels to runs/train/exp3/labels.jpg... 

AutoAnchor: 5.85 anchors/target, 1.000 Best Possible Recall (BPR). Current anchors are a good fit to dataset ✅
Image sizes 416 train, 416 val
Using 2 dataloader workers
Logging results to runs/train/exp3
Starting training for 150 epochs...

     Epoch   gpu_mem       box       obj       cls    labels  img_size
     0/149     1.61G   0.08572    0.1166   0.02635        36       416: 100% 115/115 [00:20<00:00,  5.55it/s]
               Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100% 6/6 [00:00<00:00,  6.00it/s]
                 all        175       2250      0.502      0.231      0.138     0.0433

     Epoch   gpu_mem       box       obj       cls    labels  img_size
     1/149     1.97G   0.06362    0.1082   0.01141        73       416: 100% 115/115 [00:17<00:00,  6.52it/s]
               Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100% 6/6 [00:00<00:00,  6.66it/s]
                 all        175       2250      0.386      0.561      0.402      0.104

.
.
.
.
     Epoch   gpu_mem       box       obj       cls    labels  img_size
   149/149     1.97G   0.01586    0.0505 0.0003206        28       416: 100% 115/115 [00:17<00:00,  6.66it/s]
               Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100% 6/6 [00:00<00:00,  7.82it/s]
                 all        175       2250      0.884      0.821      0.886      0.602

150 epochs completed in 0.766 hours.
Optimizer stripped from runs/train/exp3/weights/last.pt, 14.3MB
Optimizer stripped from runs/train/exp3/weights/best.pt, 14.3MB

Validating runs/train/exp3/weights/best.pt...
Fusing layers... 
Model summary: 213 layers, 7018216 parameters, 0 gradients, 15.8 GFLOPs
               Class     Images     Labels          P          R     mAP@.5 mAP@.5:.95: 100% 6/6 [00:03<00:00,  1.70it/s]
                 all        175       2250      0.863      0.834      0.888      0.604
           Platelets        175        173      0.779      0.879      0.886      0.456
                 RBC        175       1908      0.854      0.642      0.798      0.556
                 WBC        175        169      0.956      0.982       0.98        0.8
Results saved to runs/train/exp3

6。ok, 跑完了 150 个 epoch，总算把 model train 完，其实还蛮快的。 Train 好的 model 会收在 runs/train/exp3/weights/ 的 folder 里，里面有一个 best.pt 的 file, 那是整个 training 过

程中找到最 optimized 的 model 。至于其他的 model training 资料也可以在 exp3 的 folder 里

面找到。

7。接下来可以用 tensorboard 把 model training performance display 出来，这可是我第一次成功的用到 tensorboard。真的要感谢 Roboflow 的 script。至于要怎样看这些 chart，这里我不多记录。

# Start tensorboard
# Launch after you have started training
# logs save in the folder "runs"
%load_ext tensorboard
%tensorboard --logdir '/content/drive/My Drive/yolov5/yolov5/runs'

8。最后，我们可以用以下的 code 来把 model call 出来做 influencing 。Influence result 会收在 runs/detect/exp2 的 folder。

现在问题来了，runs/detect/exp2 folder 里面收的都是处理好的图片，如果说我要 object detection 的 coordinate data，要怎么弄出来？这个还得去 detect.py 的 script 里面研究研究。

# test the model 
!python "/content/drive/My Drive/yolov5/yolov5/detect.py" --weights '/content/drive/My Drive/yolov5/yolov5/runs/train/exp2/weights/best.pt' --img 416 --conf 0.1 --source '/content/drive/My Drive/yolov5/test/images'

detect: weights=['/content/drive/My Drive/yolov5/yolov5/runs/train/exp2/weights/best.pt'], source=/content/drive/My Drive/yolov5/test/images, data=data/coco128.yaml, imgsz=[416, 416], conf_thres=0.1, iou_thres=0.45, max_det=1000, device=, view_img=False, save_txt=False, save_conf=False, save_crop=False, nosave=False, classes=None, agnostic_nms=False, augment=False, visualize=False, update=False, project=runs/detect, name=exp, exist_ok=False, line_thickness=3, hide_labels=False, hide_conf=False, half=False, dnn=False
fatal: cannot change to '/content/drive/My': No such file or directory
YOLOv5 🚀 2022-4-30 torch 1.11.0+cu113 CUDA:0 (Tesla T4, 15110MiB)

Fusing layers... 
Model summary: 213 layers, 7018216 parameters, 0 gradients, 15.8 GFLOPs
image 1/87 /content/drive/My Drive/yolov5/test/images/BloodImage_00002_jpg.rf.995f1b91c3e39b6a26382e05a028a74d.jpg: 416x416 1 Platelets, 41 RBCs, 1 WBC, Done. (0.009s)
image 2/87 /content/drive/My Drive/yolov5/test/images/BloodImage_00005_jpg.rf.a13d592d5f2b1c5c16de54558237b636.jpg: 416x416 2 Plateletss, 44 RBCs, 1 WBC, Done. (0.012s)
.
.
.
.
image 85/87 /content/drive/My Drive/yolov5/test/images/BloodImage_00390_jpg.rf.cb25074254c90ec49780905d99593c5e.jpg: 416x416 26 RBCs, 1 WBC, Done. (0.010s)
image 86/87 /content/drive/My Drive/yolov5/test/images/BloodImage_00405_jpg.rf.6b1b91f7b89d81bf525f941752af9606.jpg: 416x416 5 Plateletss, 39 RBCs, 2 WBCs, Done. (0.010s)
image 87/87 /content/drive/My Drive/yolov5/test/images/BloodImage_00409_jpg.rf.f9ee5147e9335ba5f06ff49435673a8e.jpg: 416x416 12 Plateletss, 51 RBCs, 1 WBC, Done. (0.011s)
Speed: 0.4ms pre-process, 11.1ms inference, 1.0ms NMS per image at shape (1, 3, 416, 416)
Results saved to runs/detect/exp2

9。如果说要把 runs/detect/exp2 里面的图片从 notebook 里 display 出来，可以试用以下的 code

#display inference on ALL test images

import glob
from IPython.display import Image, display

for imageName in glob.glob('/content/drive/My Drive/yolov5/yolov5/runs/detect/exp2/*.jpg'): #assuming JPG
    display(Image(filename=imageName))
    print("\n")

Ok，完成。

How To Prepare Training Dataset For Yolo v5 PyTorch Object Detection Model With Roboflow

noreply@blogger.com (I Talk - You Do) — Sat, 07 May 2022 05:11:00 +0000

Roboflow 主要是一个 image analytic ai model training platform。

去年的时候我就发现这个工具，也开了一个 account，但也只是路过，由于不想把一些和工作有关的图片上传到这些陌生的免费工具上，所以，当时也没有停留多加了解这工具的欲愿。

也不知吹了什么头风，今天突然下定决心必须执行给自己欠下已久的 action item，那就是把 yolo object detection model training 学上，在网上趴了这个 Youtube link 回来。(一般来说，在网上趴资料的话，我还是比较喜欢看那些如 toward datascience 或是 medium 之类的 web page，我很少回去开 Youtube 的 tutuorial 来看的，也不知道为什么，今天我会去 click 这个 link，而且还吧他给看完)

也因为这个视频，我学上了如何用 Roboflow 来准备 yolov5 需要的 training data set format。（原来是那么简单的）。

由于视频的 tutorial 是以 macbook 来做示范，展示的界面和 windows 有些不同，所以我觉得还是把我用 roboflow 准备 dataset 的过程给记录下来，方便以后参考。

Step 1 在 Roboflow 开一个户口。如果没有记错的话，然后 sign in。如果么有记错的话，Roboflow 好像不接受 gmail 或是 yahoo 的个人 emial。需要公司或是大学的 email 来注册。

Step 2 Sign in 了过后会来到这个界面。

Step 3 Upload dataset，Roboflow 也提供了不少免费的 dataset 供试验使用，今天我就根据 Youtube 视频的示范 dowloand 了blood cell dataset 来做试验（注意 step 2 图左边的 side bar，click Public Datasets。我选了以下的 Dataset

点了小格子后就会来到这个 data 下载界面。这界面也提供了一些 dataset 的 property。至于 dataset 的 property，这里就不多解释。

我点了 raw （这里我选了 raw 主要是接下来我要自己做 data augmentation ）之后，就来到这个下载的界面。要注意的是，这里提供了不同的 data label format，我选了 Pascal VOC XML format。还有我们也可以设定 train, valid 和 test data split。Roboflow 会在下载的时候自动的把 data 分出来。（多么的方便，是吧？）

点了 Pascal VOC XML 之后，这个窗口就自动弹出，确定了就可以点 Continue

下载完成，去 Downloads folder 查看下载的 dataset对不对。

下载的 zip file 里面应该是个样子的，test, train, valid folder 里面每一张图都带有一个 xml file。

OK，data download 成功。

Step 4 下来的是步骤就是如何用 Roboflow 这个工具把 Pascal VOL XML label format 的 dataset 转换为 YoloV5 competible 的 dataset。

如果是新 user 的话，首先我们需要在 Roboflow Home 那里开一个新的 Workspace。（一般 Roboflow 会有一个 default 的 Workspace，叫 Roboflowtest。我就直接用这个 Workspace 上载我的 dataset。

先点一下 + Create New Project ，然后把弹出来的 form 给填好（这里出现 Create Public Project。如果你开新的 Workspace，选择 Business 的话，Roboflow 会建议你开一个 Private Sand Box，这个时候弹出来的窗口会有点不一样）

之后就来到这个界面，然后选 select folder。可以一次过把 train test valid folder 的data upload 上去，到时候 Roboflow 会把所有的 data combine，再 split 过。

Upload 之后就会出现这养的界面，这个界面也提供了一些 data property 的资料

其实刚刚上载上去的都是 Pascal VOC XML 的 dataset。接下来点 Generate New Version

在这个界面，如果有需要的话，我们还可以做一些 data preprocessing，data augmentation 的步骤，最后才点 Generate。

点了 Generate 以后，就会有新的界面跳出来。

Step 5 点 Export 刚弄好的新 data set，在弹出来的窗口上选择新的 dataset format，Roboflow 就会自动的把需要的格式转换好才下载。由于接下来我要做的是 train Yolo v5 PyTorch 的 object detection model，Yolo v5 PyTorch 用的 data 是 csv format，所以我 download 下来的 annotation file 应该是 csv 的格式。

好，我来看看我 downlaod 下来的 dataset 是不是对的。

从 download 下来的 file structure，我们可以看到 Yolo v5 PyTorch 的 dataset，images 和 label 是收在分开的 folder 的，annotation file 也是 csv 格式。也就是说，datasets 格式转换成功。

dataset 弄好，接下来就是 model training script setup 了。至于 training script，也可以在 Roboflow 的网页里面找到（但需要做一些 modification 才会跑）。这里我只是 show 如何弄到 Roboflow 的 training script，至于那些细节，我在下一个 post 才谈。

去 Roboflow Project 左边的 side bar 点 Model Library，选 Yolo v5 PyTorch 点进 YOLOR Colab Notebook 的 link，就可以在 colab 拿到 training script，还有清楚的备注。多好。

但，这个原本的 script 毕竟是 for demo purpose，还需要 Roboflow 的 security key，我不太喜欢，所以需要做一些修改。

至于需要做哪些修改，下个 post 再谈吧。

好，今天到处为止。

How To Build A Gaussian Mixed Model (GMM) Model For Data Clustering

noreply@blogger.com (I Talk - You Do) — Sun, 17 Apr 2022 03:37:00 +0000

很久以前就有听过这 GMM 的玩意儿，至于 GMM 这葫芦里卖的是什么药，说实在的，我真的是没有什么概念。只知道它是 unsupervised learning 的一种。每次想到这个 topic，就会提醒自己必须花些时间来把这个 topic 搞清楚。讲了一年多，都没有实际行动，一大堆理由倒是真的。直到去年年尾总结的时候，告诉自己，无论如何都要把这债还清。所以，逼自己花了两天的时间来研究研究。至少让我对 GMM 这玩意多一些了解。

从网上趴回来的资料，得到了一个重点，其实 GMM 和 k-mean 差不多。但是 k-mean 本身有一个缺点，那就是当它找到某个 cluster data 的 mean 值的时候，它会假设所有在 mean 值直径范围内的点都属于同样一个 cluster。但，实际上我们的 data 不是这样分布，一般的 data 都是比较倾向于正态分布的，所以很多时候 k-mean 会把不同的 cluster 归类于同样一个 cluster，结果影响了 classification accuracy。GMM 的出现把这问题解决，这也是为啥 GMM 会普遍使用的其中一个原因。

几个网上趴回来的资料当中，这资料对我来说是比较完整，而且 code 也可以用。所以我必须把它给记录下来，以防万一。

ref link : GMM: Gaussian Mixture Models — How toSuccessfully Use IttoClusterYour Data?

以下是从参考资料那来复制过来的码，试过了，行得通。可以留着自己用。

# ref : https://towardsdatascience.com/gmm-gaussian-mixture-models-how-to-successfully-use-it-to-cluster-your-data-891dc8ac058f
# map can't show up if open with jupyterlab. have to open with juypternotebook

import pandas as pd # for data manipulation
import numpy as np # for data manipulation

from sklearn.mixture import GaussianMixture # for GMM clustering
from sklearn import metrics # for calculating Silhouette score

import matplotlib.pyplot as plt # for data visualization
import plotly.express as px  # for data visualization
import plotly.graph_objects as go # for data visualization

from geopy.geocoders import Nominatim # for getting city coordinates
from progressbar import ProgressBar # for displaying progress 
import time # for adding time delays

# Set Pandas options to display more columns
pd.options.display.max_columns=50

# Read in the weather data csv
df=pd.read_csv('weatherAUS.csv', encoding='utf-8')

# Drop records where target RainTomorrow=NaN
df=df[pd.isnull(df['RainTomorrow'])==False]

# For other columns with missing values, fill them in with column mean
df=df.fillna(df.mean())

# Add spaces between multiple words in location names
df['Location2']=df['Location'].str.replace( r"([A-Z])", r" \1").str.strip()
# Update Location for Pearce RAAF so it can be found by geolocator
df['Location2']=df['Location2'].apply(lambda x: 'Pearce, Bullsbrook' if x=='Pearce R A A F' else x)

# Show a snaphsot of data
df

Date Location MinTemp MaxTemp Rainfall Evaporation Sunshine WindGustDir WindGustSpeed WindDir9am WindDir3pm WindSpeed9am WindSpeed3pm Humidity9am Humidity3pm Pressure9am Pressure3pm Cloud9am Cloud3pm Temp9am Temp3pm RainToday RainTomorrow Location2
0 2008-12-01 Albury 13.4 22.9 0.6 5.469824 7.624853 W 44.0 W WNW 20.0 24.0 71.0 22.0 1007.7 1007.1 8.000000 4.503167 16.9 21.8 No No Albury
1 2008-12-02 Albury 7.4 25.1 0.0 5.469824 7.624853 WNW 44.0 NNW WSW 4.0 22.0 44.0 25.0 1010.6 1007.8 4.437189 4.503167 17.2 24.3 No No Albury
2 2008-12-03 Albury 12.9 25.7 0.0 5.469824 7.624853 WSW 46.0 W WSW 19.0 26.0 38.0 30.0 1007.6 1008.7 4.437189 2.000000 21.0 23.2 No No Albury
3 2008-12-04 Albury 9.2 28.0 0.0 5.469824 7.624853 NE 24.0 SE E 11.0 9.0 45.0 16.0 1017.6 1012.8 4.437189 4.503167 18.1 26.5 No No Albury
4 2008-12-05 Albury 17.5 32.3 1.0 5.469824 7.624853 W 41.0 ENE NW 7.0 20.0 82.0 33.0 1010.8 1006.0 7.000000 8.000000 17.8 29.7 No No Albury
... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
145454 2017-06-20 Uluru 3.5 21.8 0.0 5.469824 7.624853 E 31.0 ESE E 15.0 13.0 59.0 27.0 1024.7 1021.2 4.437189 4.503167 9.4 20.9 No No Uluru
145455 2017-06-21 Uluru 2.8 23.4 0.0 5.469824 7.624853 E 31.0 SE ENE 13.0 11.0 51.0 24.0 1024.6 1020.3 4.437189 4.503167 10.1 22.4 No No Uluru
145456 2017-06-22 Uluru 3.6 25.3 0.0 5.469824 7.624853 NNW 22.0 SE N 13.0 9.0 56.0 21.0 1023.5 1019.1 4.437189 4.503167 10.9 24.5 No No Uluru
145457 2017-06-23 Uluru 5.4 26.9 0.0 5.469824 7.624853 N 37.0 SE WNW 9.0 9.0 53.0 24.0 1021.0 1016.8 4.437189 4.503167 12.5 26.1 No No Uluru
145458 2017-06-24 Uluru 7.8 27.0 0.0 5.469824 7.624853 SE 28.0 SSE N 13.0 7.0 51.0 24.0 1019.4 1016.5 3.000000 2.000000 15.1 26.0 No No Uluru
142193 rows × 24 columns

# Create a list of unique locations (cities)
loc_list=list(df.Location2.unique())

geolocator = Nominatim(user_agent="add-your-agent-name")
country ="Australia"
loc_res=[]

pbar=ProgressBar() # This will help us to show the progress of our iteration
for city in pbar(loc_list):
    loc = geolocator.geocode(city+','+ country)
    res = [city, loc.latitude, loc.longitude]
    loc_res = loc_res + [res]
    time.sleep(1) # sleep for 1 second before submitting the next query

# Add locations to a dataframe
df_loc=pd.DataFrame(loc_res, columns=['Loc', 'Latitude', 'Longitude'])

# Show data
df_loc

Loc Latitude Longitude
0 Albury -36.080477 146.916280
1 Badgerys Creek -33.881667 150.744163
2 Cobar -31.498333 145.834444
3 Coffs Harbour -30.296241 153.113529
4 Moree -29.461720 149.840715
5 Newcastle -32.919295 151.779535
6 Norah Head -33.281667 151.567778
7 Norfolk Island -29.028958 167.958729
8 Penrith -33.751079 150.694168
9 Richmond -37.820395 145.002515
10 Sydney -33.869844 151.208285
11 Sydney Airport -33.933776 151.179927
12 Wagga Wagga -35.115000 147.367778
13 Williamtown -32.815000 151.842778
14 Wollongong -34.424394 150.893850
15 Canberra -35.297591 149.101268
16 Tuggeranong -35.420977 149.092134
17 Mount Ginini -35.529744 148.772540
18 Ballarat -37.562303 143.860565
19 Bendigo -36.758877 144.282593
20 Sale -38.105036 147.064790
21 Melbourne Airport -37.666951 144.833493
22 Melbourne -37.814218 144.963161
23 Mildura -34.184726 142.162497
24 Nhil -35.471309 141.306236
25 Portland -38.345623 141.604230
26 Watsonia -37.711002 145.083635
27 Dartmoor -37.922544 141.276655
28 Brisbane -27.468968 153.023499
29 Cairns -16.920666 145.772185
30 Gold Coast -28.002373 153.414599
31 Townsville -19.256939 146.823954
32 Adelaide -34.928181 138.599931
33 Mount Gambier -37.824670 140.782007
34 Nuriootpa -34.469335 138.993901
35 Woomera -31.199914 136.825353
36 Albany -35.024782 117.883608
37 Witchcliffe -34.026335 115.100477
38 Pearce, Bullsbrook -31.673960 116.017544
39 Perth Airport -31.940610 115.967608
40 Perth -31.955896 115.860580
41 Salmon Gums -32.981535 121.643942
42 Walpole -34.977680 116.731006
43 Hobart -42.882509 147.328123
44 Launceston -41.434081 147.137350
45 Alice Springs -23.698388 133.881289
46 Darwin -12.460440 130.841047
47 Katherine -14.464616 132.263599
48 Uluru -25.344857 131.032517

Loc	Latitude	Longitude
0	Albury	-36.080477	146.916280
1	Badgerys Creek	-33.881667	150.744163
2	Cobar	-31.498333	145.834444
3	Coffs Harbour	-30.296241	153.113529
4	Moree	-29.461720	149.840715
5	Newcastle	-32.919295	151.779535
6	Norah Head	-33.281667	151.567778
7	Norfolk Island	-29.028958	167.958729
8	Penrith	-33.751079	150.694168
9	Richmond	-37.820395	145.002515
10	Sydney	-33.869844	151.208285
11	Sydney Airport	-33.933776	151.179927
12	Wagga Wagga	-35.115000	147.367778
13	Williamtown	-32.815000	151.842778
14	Wollongong	-34.424394	150.893850
15	Canberra	-35.297591	149.101268
16	Tuggeranong	-35.420977	149.092134
17	Mount Ginini	-35.529744	148.772540
18	Ballarat	-37.562303	143.860565
19	Bendigo	-36.758877	144.282593
20	Sale	-38.105036	147.064790
21	Melbourne Airport	-37.666951	144.833493
22	Melbourne	-37.814218	144.963161
23	Mildura	-34.184726	142.162497
24	Nhil	-35.471309	141.306236
25	Portland	-38.345623	141.604230
26	Watsonia	-37.711002	145.083635
27	Dartmoor	-37.922544	141.276655
28	Brisbane	-27.468968	153.023499
29	Cairns	-16.920666	145.772185
30	Gold Coast	-28.002373	153.414599
31	Townsville	-19.256939	146.823954
32	Adelaide	-34.928181	138.599931
33	Mount Gambier	-37.824670	140.782007
34	Nuriootpa	-34.469335	138.993901
35	Woomera	-31.199914	136.825353
36	Albany	-35.024782	117.883608
37	Witchcliffe	-34.026335	115.100477
38	Pearce, Bullsbrook	-31.673960	116.017544
39	Perth Airport	-31.940610	115.967608
40	Perth	-31.955896	115.860580
41	Salmon Gums	-32.981535	121.643942
42	Walpole	-34.977680	116.731006
43	Hobart	-42.882509	147.328123
44	Launceston	-41.434081	147.137350
45	Alice Springs	-23.698388	133.881289
46	Darwin	-12.460440	130.841047
47	Katherine	-14.464616	132.263599
48	Uluru	-25.344857	131.032517

# Create a figure
fig = go.Figure(data=go.Scattergeo(
        lat=df_loc['Latitude'],
        lon=df_loc['Longitude'],
        hovertext=df_loc['Loc'], 
        mode = 'markers',
        marker_color = 'red',
        ))

# Update layout so we can zoom in on Australia
fig.update_layout(
        width=980,
        height=720,
        margin={"r":0,"t":10,"l":0,"b":10},
        geo = dict(
            scope='world',
            projection_type='miller',
            landcolor = "rgb(250, 250, 250)",
            center=dict(lat=-25.69839, lon=139.8813), # focus point
            projection_scale=6 # zoom in on
        ),
    )

fig.show()

# Create empty list
S=[]

# Range of clusters to try (2 to 10)
K=range(2,11)

# Select data for clustering model
X = df_loc[['Latitude', 'Longitude']]

for k in K:
    # Set the model and its parameters
    model = GaussianMixture(n_components=k, n_init=20, init_params='kmeans')
    # Fit the model 
    labels = model.fit_predict(X)
    # Calculate Silhoutte Score and append to a list
    S.append(metrics.silhouette_score(X, labels, metric='euclidean'))

# Plot the resulting Silhouette scores on a graph
plt.figure(figsize=(16,8), dpi=300)
plt.plot(K, S, 'bo-', color='black')
plt.xlabel('k')
plt.ylabel('Silhouette Score')
plt.title('Identify the number of clusters using Silhouette Score')
plt.show()

# Select data for clustering model
X = df_loc[['Longitude', 'Latitude']]

# Set the model and its parameters - 4 clusters
model4 = GaussianMixture(n_components=4, # this is the number of clusters
                         covariance_type='full', # {‘full’, ‘tied’, ‘diag’, ‘spherical’}, default=’full’
                         max_iter=100, # the number of EM iterations to perform. default=100
                         n_init=1, # the number of initializations to perform. default = 1
                         init_params='kmeans', # the method used to initialize the weights, the means and the precisions. {'random' or default='k-means'}
                         verbose=0, # default 0, {0,1,2}
                         random_state=1 # for reproducibility
                        )

# Fit the model and predict labels
clust4 = model4.fit(X)
labels4 = model4.predict(X)

# Generate 10,000 new samples based on the model
smpl=model4.sample(n_samples=10000)

# Print model summary
print('*************** 4 Cluster Model ***************')
#print('Weights: ', clust4.weights_)
print('Means: ', clust4.means_)
#print('Covariances: ', clust4.covariances_)
#print('Precisions: ', clust4.precisions_)
#print('Precisions Cholesky: ', clust4.precisions_cholesky_)
print('Converged: ', clust4.converged_)
print(' No. of Iterations: ', clust4.n_iter_)
#print('Lower Bound: ', clust4.lower_bound_)

*************** 4 Cluster Model ***************
Means:  [[117.02852927 -33.22588073]
 [150.12384738 -33.45513888]
 [142.80407729 -37.14718707]
 [136.85134074 -18.78277472]]
Converged:  True
 No. of Iterations:  10

# Attach cluster labels to the main dataframe
df_loc['Clust4']=labels4

# Create a figure
fig = go.Figure(data=go.Scattergeo(
        lat=df_loc['Latitude'],
        lon=df_loc['Longitude'],
        hovertext=df_loc[['Loc', 'Clust4']], 
        mode = 'markers',
        marker=dict(colorscale=['#ae34eb', 'red', 'blue', '#34eb34']),
        marker_color = df_loc['Clust4'],
        ))

# Update layout so we can zoom in on Australia
fig.update_layout(
        showlegend=False,
        width=1000,
        height=760,
        margin={"r":0,"t":30,"l":0,"b":10},
        geo = dict(
            scope='world',
            projection_type='miller',
            landcolor = "rgb(250, 250, 250)",
            center=dict(lat=-25.69839, lon=139.8813), # focus point
            projection_scale=6 # zoom in on
        ),
    )
fig.show()

# Create a figure
fig = go.Figure(data=go.Scattergeo(
        lat=smpl[0][:,1],
        lon=smpl[0][:,0],
        mode = 'markers',
        marker=dict(colorscale=['#ae34eb', 'red', 'blue', '#34eb34']),
        marker_color = smpl[1],
        marker_size=3
        ))

# Update layout so we can zoom in on Australia
fig.update_layout(
        showlegend=False,
        width=1000,
        height=760,
        margin={"r":0,"t":30,"l":0,"b":10},
        geo = dict(
            scope='world',
            projection_type='miller',
            landcolor = "rgb(250, 250, 250)",
            center=dict(lat=-25.69839, lon=139.8813), # focus point
            projection_scale=6 # zoom in on
        ),
    )
fig.show()

OK, 就这样完成。

其实以上的 script 我是在一月份测试的，当时用着 jupyterlab，就是无法把地图搞出来，但是用 jupyternotebook 又没问题。

今天再次用 jupyterlab 来测试，地图的问题不见了。到底出了什么问题，我自己也不知道。总之，以上的码是没问题的。

How To Convert Pascol VOC To Coco (xml to json)

noreply@blogger.com (I Talk - You Do) — Sat, 25 Dec 2021 16:27:00 +0000

之前在学 EfficientDet object detection model training 碰到最大的问题，就是在准备 training data 这一块。Tensorflow 有他们自己的方法，pytorch 也有他们自己的一套。因为这个问题，花了不少时间才搞清楚。

如果要用 pytorch 来 train EfficientDet ojbect detection model，那么，我必须把 annotated 在 Pascol VOC xml 格式的 data file 转换成 Coco json 格式。今天要记录的就是这个 data file 格式的转换。

这个方法是我在 git hub 上扒回来的。跟着步骤做就可以。

1. pip install lxml

2. 开一个 folder 把这些 file 都放进去。

3. 把用 labelimg 弄好的 xml file 都存进 Annotations 的 folder 里

4. 把说有的 xml filename list 在 notepad 里然后 save as xmllist.txt。

5. 上 github download voc2coco-master 下来收进 folder。然后把 voc2coco.py 的 file copy 出来，总之必须弄到和上图一样就是。

6. 打开 anaconda terminal, change directory 去上图的那个 folder，然后 copy 以下的 command paste 在 terminal enter。

python voc2coco.py xmllist.txt ./Annotations output.json

如果一切顺利，应该会看到以下结果

folder 里也会多了个 output.json 的 data file 出来。用 notepad 打打开来看，应该是这样的格式的。

就这样完成了一个 data file 的转换。

在 EfficientDet object detection model training，我们需要准备一个 training 和 testing 的 json data file。

好，今天就这么多，接下来就要记录 train EfficientDet 的过程了

How To Visualize Feature Map of CNN With Python

noreply@blogger.com (I Talk - You Do) — Wed, 22 Dec 2021 14:03:00 +0000

曾经看过专家示范如何把 CNN 在处理图像的时候，把图像经过每一个 layer 的 feature map 给弄出来，好让我们能够了解 CNN 在做 feature extraction 的时候，到底 pickup 了什么样的 feature。

今日心血来潮，再次翻转了整个 Google，终于给我在 Kaggle 里找到了一个能够让我明白的 script。原来的 script 只是选用了 VGG16 ，后来我也尝试了用 Efficientnet，也行

在这个示范，我用了以下的图片，导出了 layer 2, 3, 4, 5, 6, 7 的 feature map 。

注：最少要选两个 layer，如果只设定一个 layer 的话，那么会出现 error ，也不知道为啥

# ref : https://www.kaggle.com/loaiabdalslam/vgg16-layers-visualization-tutorial
# visualize feature maps output from each block in the vgg model
from keras.applications.vgg16 import VGG16
from keras_efficientnets import EfficientNetB0
from keras.applications.vgg16 import preprocess_input
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
from keras.models import Model
import matplotlib.pyplot as plt
from numpy import expand_dims
from matplotlib import pyplot 

# load the model (select one model)
#model = VGG16()
model = EfficientNetB0()

# redefine model to output right after the first hidden layer
ixs = [2,3,4,5,6,7]
outputs = [model.layers[i].output for i in ixs]
model = Model(inputs=model.inputs, outputs=outputs)
model.summary()

# load the image with the required shape
# convert the image to an array
img = load_img(f'C:/Users/mokf/FAV_ADC/pkg_object/dso_std/unlabel_image/test.png', target_size=(224, 224))

# convert the image to an array
img = img_to_array(img)

# expand dimensions so that it represents a single 'sample'
img = expand_dims(img, axis=0)

# prepare the image (e.g. scale pixel values for the vgg)
img = preprocess_input(img)

# get feature map for first hidden layer
feature_maps = model.predict(img)

# plot the output from each block
square = 5
for fmap in feature_maps:
    # plot all 64 maps in an 8x8 squares
    ix = 1
    for _ in range(square):
        plt.figure(figsize=(16,16))
        for _ in range(square):
           

            # specify subplot and turn of axis
            ax = pyplot.subplot(square, square, ix)
            ax.set_xticks([])
            ax.set_yticks([])

            # plot filter channel in grayscale
            plt.imshow(fmap[0, :, :, ix-1], cmap='viridis')
            ix += 1
    # show the figure    
    plt.show()

结果就是这样。还可以

How To Measure Line Straightness

noreply@blogger.com (I Talk - You Do) — Sat, 20 Nov 2021 13:51:00 +0000

公司里有个吃盐比我吃米多的老家伙告诉我，deep learning 只能够做 classification，做不到 measurement，所以 measurement 这件事情需要动用到 classical vision 软件来做。既然人家都自认吃盐比我吃米多，又是长辈，他一开口说话，就算我不认同，也只能够藏在心里。不跟他吵，主要还是为了避免他为我自造一些不必要的工作。

好，今天我就来证明他讲的都是废话，以下我写的 code，也能够测量图片上的直线的弯曲度。

我就用以下的图片来做示范

import cv2 as cv
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

image = cv.imread('line_img.png')
plt.imshow(image)

# find black pixel coordinate
color = (0, 0,0)
indices_curve = np.where(image == color)

coordinates_curve = zip(indices_curve[1], indices_curve[0]) 
unique_coordinates_curve = list(set(list(coordinates_curve)))
df1 = pd.DataFrame(unique_coordinates_curve)

# plot a red line at the two end
image2 = cv.line(image, pt1=min(unique_coordinates_curve), pt2 = max(unique_coordinates_curve), color = (200,100,100), thickness = 1)
plt.imshow(image2)

# find red pixel coordinate
color = (200, 100,100)
indices_line = np.where(image2 == color)

coordinates_line = zip(indices_line[1], indices_line[0]) 
unique_coordinates_line = list(set(list(coordinates_line)))
df2 = pd.DataFrame(unique_coordinates_line)

# rename header of df1 n df2
df1.columns =['x_curve', 'y_curve']
df2.columns =['x_line', 'y_line']

df1.sort_values(by=['x_curve'], inplace=True)
df2.sort_values(by=['x_line'], inplace=True)

# drop all repeated x coordinate
df11=df1[['x_curve','y_curve']].drop_duplicates(subset=['x_curve'])
df22=df2[['x_line','y_line']].drop_duplicates(subset=['x_line'])

# compbine df1 n df2 into 1 table
table_merge = pd.merge(df11, df22[['x_line', 'y_line']], left_on = 'x_curve', right_on = 'x_line', how = 'left')

# calculate x y delta, 
table_merge['x_delta'] = table_merge['x_curve'] - table_merge['x_line']
table_merge['y_delta'] = table_merge['y_curve'] - table_merge['y_line']

table_merge

# calculate mean square error

def mse(actual, pred): 
    actual, pred = np.array(actual), np.array(pred)
    return np.square(np.subtract(actual,pred)).mean() 

mse = mse(table_merge['y_curve'], table_merge['y_line'])
print('mean square error = ', mse)

mean square error = 318.2432432432432

# calculate max deviation 
max_deviation = max(table_merge['y_delta'])
print('max_deviation = ', max_deviation)

max_deviation = 25

# histogram of y_delta distribution 
plt.hist(table_merge['y_delta'], bins = 20)
plt.show()

# scatter plot

ax1 = table_merge.plot(kind='scatter', x='x_curve', y='y_curve', color='r')    
ax2 = table_merge.plot(kind='scatter', x='x_line', y='y_line', color='b', ax=ax1)   
#print(ax1 == ax2)  # True
plt.gca().invert_yaxis()
plt.show()

table_merge.to_csv('table_merge.csv', header=True, index=False)

最后，用几个不同曲线的图片来测试了我的 code，基本上都能准确的测量了曲线的弯度。

XGBoost Regression Model - R

noreply@blogger.com (I Talk - You Do) — Mon, 08 Nov 2021 04:20:00 +0000

前几天有个同事发了一些数据过来，问我是否能够用 machine learning 来处理他的数据，他是希望能够用 machine learning 的方式来自动化他经常要做的 Yield Forecast。看了看他的数据，我觉得还是有机会的。之前听了一些专家讨论了 XGBoost 这个 algro，今天我也来尝试用这组数据来弄个 model 出来。另外，我选择用 R 来做，第一个理由是很久没用了，应该要练习练习，要不，迟早会把这语言忘得一干二净。另一个理由呢，就是我还是觉得 R 比较容易上手。

我拿到的数据格式是这个样子的。y 是 continuous data ，x 基本上都是 categorical data。所以，x 那一部分需要做一些处理才可以使用。不用多说，肯定是 one hot encoding 了。

在网上扒了一些参考资料回来，就跟着做，基本上没什么大问题。

以下就是我的 R code 。

# ref : https://www.analyticsvidhya.com/blog/2016/01/xgboost-algorithm-easy-steps/

# load required packages
library(xgboost)
library(readr)
library(stringr)
library(caret)
library(car)

# set working directory
setwd("C:/Users/mokf/Desktop/xgboost")


#load raw data
data = read_csv("data.csv")
df_all = data[, c('Yield','BNR', 'Package_Class','Glue', 'LF_Material', 'Basic_Type', 'Backend_Segment',
                  'Process_Line', 'Technology', 'Moulding_Compound', 'Month')]

#convert input variable into categorical format
df_all$Glue = as.factor(df_all$Glue)
df_all$LF_Material = as.factor(df_all$LF_Material)
df_all$Basic_Type = as.factor(df_all$Basic_Type)
df_all$BNR = as.factor(df_all$BNR)
df_all$Package_Class = as.factor(df_all$Package_Class)
df_all$Backend_Segment = as.factor(df_all$Backend_Segment)
df_all$Technology = as.factor(df_all$Technology)
df_all$Process_Line = as.factor(df_all$Process_Line)
df_all$Moulding_Compound = as.factor(df_all$Moulding_Compound)
df_all$Month = as.factor(df_all$Month)


# one hot encoding categorical features
df_all_x = df_all
df_all_x$Yield = NULL
dummies <- dummyVars(~. , data = df_all_x)

df_all_ohe <- as.data.frame(predict(dummies, newdata = df_all_x))
df_all_ohe$Yield = data$Yield

# prepare training and testing dataset
set.seed(123)
intrain = createDataPartition(y = df_all_ohe$Yield, p = 0.9, list = FALSE)
training = df_all_ohe[intrain,]
testing = df_all_ohe[-intrain,]

x_train = training 
x_train$Yield = NULL
y_train = training$Yield

x_test = testing 
x_test$Yield = NULL

# start xgboost model training
xgb = xgboost(data = data.matrix(x_train),
              label = y_train,
              missing = NA,
              weight = NULL,
              params = list(),
              nrounds = 1000,
              verbose = 1,
              print_every_n = 1L,
              early_stopping_rounds = NULL,
              maximize = NULL,
              save_period = NULL,
              save_name = "xgboost.model",
              xgb_model = NULL,
              callbacks = list(),
             
              )

# model validataion with test dataset
y_pred = predict(xgb, data.matrix(x_test))


# visualize actual vs predicted yield 
y_test = as.data.frame(testing$Yield)
y_test$pred = y_pred
y_test$id = as.integer(row.names(x_test))

library(reshape2)
df = melt(y_test, id.vars = 'id', variable_name = 'series')

ggplot(df, aes(x = id, y = value)) + 
  geom_line(aes(colour = variable))

df_all_final_rpt = df_all
df_all_final_rpt$id = row.names(df_all)
final_rpt = merge(x=y_test,y=df_all_final_rpt,by='id',all.x=TRUE)


write.csv(final_rpt, 'final_rpt')

#end

以下是用 test dataset 预测出来的结果，由于数据不是很完整，所以我只做了一个简单的测试，只是讨个感觉，没有必要花时间去优化。

从图表看来，感觉上还可以，准确性还蛮高的。

How To Train Semantic Segmentation Model With UNet

noreply@blogger.com (I Talk - You Do) — Sat, 30 Oct 2021 05:33:00 +0000

上个 post 提到试用了 pixellib 这个工具的一些经验，过后发现，这个工具是用 pre-trained Ade20k 的 model 来做 semantic segmentation 和 mask rcnn 来做 instant semantic segmentation 。Ade20k 是用他们自己的 data set 来做 model training 的，说实在的，我花了几个礼拜的时间，翻透了整个 google，都找不到一些能够让我这种 python 小白看得明白的文章，让我能够用自己的 dataset 来 train 一个 semantic segmentation model 出来。

能够让我用 pixellib train 自己的 custom object image segmentation model 的，就只有那个 mask rcnn 了，严格来说，这是 instant semantic segmentation，不是 semantic segmentation。其实，根据 pixcellib 的示范，要用 mask rcnn 来 train instant semantic segmentation model 并不难。只要有图片，用 labelme 做一些 .json 的 label data 出来就可以了。而且这 model 还可以提供比 semantic segmentation 更多的功能，如 object classification, object localization。这些是一般 semantic segmentation model 无法做到的。既然如此，为啥我还需要浪费时间去研究那比较落伍的 semantic segmentation 呢？难道 mask rcnn 不香吗？

ok，mask rcnn 固然很好，但是唯一的问题就是这 network 比较大，不止用起来比较慢，model training 没有 GPU 的话肯定上不了，所以，如果说根据特定 AI solution 来看，如果说没那个必要，mask rcnn 不会是我的最佳选择。因此，我需要学会用自己的 dataset 来做一个 semantic segmentation model.

从 google 里扒了不少有关 semantic segmentation 的做法回来，了解了一些基本的 concept，也大概知道是怎么做的，但是却扒不到一个适合我这 python 小白看的懂的 tutorial，而且大部分的 tutorial 都用了 oxford pet 的 dataset。而且他们的 code 都直接 link 去相关 dataset 的 depository，一条 code，所有的 data 就这样下来了，如果说我要用自己准备的 dataset，那么要怎么搞？哈哈。。。问题来了。。。也就这个原因，我的确花了不少的时间来解决这些问题，终于。。。。。我把问题解决，也弄了个自己的 semantic segmentation model。

这是我付出相当大努力才完成的事情，是有必要清楚的记录下来，免得日后忘了，需要用到的时候又得从新开始。

一下记录的是 train custom semantic segmentation 的重要过程

1. 准备 dataset ，这里我用的是 pixellib 用来做 custom mask rcnn instant semantic segmentation model training 的 natural's dataset，可以直接 download . 这 dataset 里有原图和 label 好的 json file。但没有 semantic segmentation 需要用到的 mask。没关系，labelme 里面有个 labelme_json_to_dataset 的功能能够让我把 json file 里的数据转为图片，转出来的图片包括原图，label ,label bin，还有一个 .txt file。

用以下的 code 就能够很快的把需要用到的 mask 弄到手，由于原来的 dataset 图片数量不多，所以这里我也顺便做了一些 image augmentation 的 process。

import os
import sys
import labelme
import cv2
import pandas
import numpy as np
import pandas as pd
from PIL import Image
# define working directory
os.chdir('C:\\Users\\mokf\\sementic_segmentation')
base_dir_path = "."
json_files = os.path.join(base_dir_path, 'json_files')
mask_dir_path = os.path.join(base_dir_path, 'test_json')
mask_path = os.path.join(base_dir_path, 'masks_train')
img_path = os.path.join(base_dir_path, 'images_train')


for filename in os.listdir(json_files):

            if filename.endswith(".json"):
                f = os.path.join(json_files,filename)
            
                f2 = filename.split('.')
                f2 = f2[0]

                # convert json file to image
                command = 'cmd /k labelme_json_to_dataset ' + f + ' -o test_json'
                os.system(command)
                
                # read the converted image and rename it according to original image name
                img = cv2.imread(os.path.join(mask_dir_path, 'img.png'),3)
                label = cv2.imread(os.path.join(mask_dir_path, 'label.png'),3)
                label_viz = cv2.imread(os.path.join(mask_dir_path, 'label_viz.png'),3)
                #label_names = pd.read_csv(os.path.join(mask_dir_path, 'label_names.txt'))
            
                dim = (200,200)
                img = cv2.resize(img, dim, interpolation = cv2.INTER_AREA)  
                label = cv2.resize(label, dim, interpolation = cv2.INTER_AREA)
                
                cv2.imwrite(os.path.join(img_path, f2 + ".png"), img)
                cv2.imwrite(os.path.join(mask_path, f2 + ".png"), label)
                
                # image augmentation 
                img_fv = cv2.flip(img, 0)
                label_fv = cv2.flip(label, 0)
                
                cv2.imwrite(os.path.join(img_path, f2 + "_fv.png"), img_fv)
                cv2.imwrite(os.path.join(mask_path, f2 + "_fv.png"), label_fv)
                
                img_fh = flipHorizontal = cv2.flip(img, 1)
                label_fh = flipHorizontal = cv2.flip(label, 1)
                
                cv2.imwrite(os.path.join(img_path, f2 + "_fh.png"), img_fh)
                cv2.imwrite(os.path.join(mask_path, f2 + "_fh.png"), label_fh)
                
                img_90 = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE)
                label_90 = cv2.rotate(label, cv2.ROTATE_90_CLOCKWISE)
                
                cv2.imwrite(os.path.join(img_path, f2 + "_90.png"), img_90)
                cv2.imwrite(os.path.join(mask_path, f2 + "_90.png"), label_90)

2. 把转换好的原图和 mask 存进 images_train 和 mask_train 的 folder 里, 必须注意的是， mask 和 image 的名字和格式是必须一样的。其实我上面的 code 已经符合这步骤的条件了。

3. 有了 dataset，现在可以开始跑我在 keras ，弄回来的 model training script 了。这是个 train Unet 的 script。

# ref : https://keras.io/examples/vision/oxford_pets_image_segmentation/
import os

# define working directory 
base_dir = '.'
input_dir = os.path.join(base_dir, "images_train")
target_dir = os.path.join(base_dir, "masks_train")
val_img_dir = os.path.join(base_dir, "images_test")
var_masks_dir = os.path.join(base_dir, "masks_test")
model_lib = os.path.join(base_dir, "model_lib")
img_size = (128, 128)
num_classes = 2
batch_size = 64

# put input image and mask side by side according to their file name
input_img_paths = sorted(
    [
        os.path.join(input_dir, fname)
        for fname in os.listdir(input_dir)
        if fname.endswith(".png")
    ]
)
target_img_paths = sorted(
    [
        os.path.join(target_dir, fname)
        for fname in os.listdir(target_dir)
        if fname.endswith(".png") and not fname.startswith(".")
    ]
)

print("Number of samples:", len(input_img_paths))

for input_path, target_path in zip(input_img_paths[:10], target_img_paths[:10]):
    print(input_path, "|", target_path)

from IPython.display import Image, display
from tensorflow.keras.preprocessing.image import load_img
import PIL
from PIL import ImageOps

# Display input image #7
display(Image(filename=input_img_paths[9]))

# Display auto-contrast version of corresponding target (per-pixel categories)
img = PIL.ImageOps.autocontrast(load_img(target_img_paths[9]))
display(img)

from tensorflow import keras
import numpy as np
from tensorflow.keras.preprocessing.image import load_img


class OxfordPets(keras.utils.Sequence):
    """Helper to iterate over the data (as Numpy arrays)."""

    def __init__(self, batch_size, img_size, input_img_paths, target_img_paths):
        self.batch_size = batch_size
        self.img_size = img_size
        self.input_img_paths = input_img_paths
        self.target_img_paths = target_img_paths

    def __len__(self):
        return len(self.target_img_paths) // self.batch_size

    def __getitem__(self, idx):
        """Returns tuple (input, target) correspond to batch #idx."""
        i = idx * self.batch_size
        batch_input_img_paths = self.input_img_paths[i : i + self.batch_size]
        batch_target_img_paths = self.target_img_paths[i : i + self.batch_size]
        
        # normalize x dataset by /255. Original script did not /255
        x = np.zeros((self.batch_size,) + self.img_size + (3,), dtype="float32")/255 
        for j, path in enumerate(batch_input_img_paths):
            img = load_img(path, target_size=self.img_size)
            x[j] = img
        
        # normalize x dataset by /255. Original script did not /255
        y = np.zeros((self.batch_size,) + self.img_size + (1,), dtype="uint8")/255
        for j, path in enumerate(batch_target_img_paths):
            img = load_img(path, target_size=self.img_size, color_mode="grayscale")
            y[j] = np.expand_dims(img, 2)
            # Ground truth labels are 1, 2, 3. Subtract one to make them 0, 1, 2:
            y[j] -= 1
        return x, y

# Unet model setup
from tensorflow.keras import layers


def get_model(img_size, num_classes):
    inputs = keras.Input(shape=img_size + (3,))

    ### [First half of the network: downsampling inputs] ###

    # Entry block
    x = layers.Conv2D(32, 3, strides=2, padding="same")(inputs)
    x = layers.BatchNormalization()(x)
    x = layers.Activation("relu")(x)

    previous_block_activation = x  # Set aside residual

    # Blocks 1, 2, 3 are identical apart from the feature depth.
    for filters in [64, 128, 256]:
        x = layers.Activation("relu")(x)
        x = layers.SeparableConv2D(filters, 3, padding="same")(x)
        x = layers.BatchNormalization()(x)

        x = layers.Activation("relu")(x)
        x = layers.SeparableConv2D(filters, 3, padding="same")(x)
        x = layers.BatchNormalization()(x)

        x = layers.MaxPooling2D(3, strides=2, padding="same")(x)

        # Project residual
        residual = layers.Conv2D(filters, 1, strides=2, padding="same")(
            previous_block_activation
        )
        x = layers.add([x, residual])  # Add back residual
        previous_block_activation = x  # Set aside next residual

    ### [Second half of the network: upsampling inputs] ###

    for filters in [256, 128, 64, 32]:
        x = layers.Activation("relu")(x)
        x = layers.Conv2DTranspose(filters, 3, padding="same")(x)
        x = layers.BatchNormalization()(x)

        x = layers.Activation("relu")(x)
        x = layers.Conv2DTranspose(filters, 3, padding="same")(x)
        x = layers.BatchNormalization()(x)

        x = layers.UpSampling2D(2)(x)

        # Project residual
        residual = layers.UpSampling2D(2)(previous_block_activation)
        residual = layers.Conv2D(filters, 1, padding="same")(residual)
        x = layers.add([x, residual])  # Add back residual
        previous_block_activation = x  # Set aside next residual

    # Add a per-pixel classification layer
    outputs = layers.Conv2D(num_classes, 3, activation="softmax", padding="same")(x)

    # Define the model
    model = keras.Model(inputs, outputs)
    return model


# Free up RAM in case the model definition cells were run multiple times
keras.backend.clear_session()

# Build model
model = get_model(img_size, num_classes)
model.summary()

import random

# Split our img paths into a training and a validation set
# val may not work properly if sal_sample set too low
val_samples = 500
random.Random(1337).shuffle(input_img_paths)
random.Random(1337).shuffle(target_img_paths)
train_input_img_paths = input_img_paths[:-val_samples]
train_target_img_paths = target_img_paths[:-val_samples]
val_input_img_paths = input_img_paths[-val_samples:]
val_target_img_paths = target_img_paths[-val_samples:]

# Instantiate data Sequences for each split
train_gen = OxfordPets(
    batch_size, img_size, train_input_img_paths, train_target_img_paths
)

val_gen = OxfordPets(batch_size, img_size, val_input_img_paths, val_target_img_paths)

# this block is main for trained model update only 
# do not run this block for 1st time training
import os
from tensorflow.keras.models import load_model
model = load_model(os.path.join(model_lib, "keras_unet_test.h5"))

# Configure the model for training.
# We use the "sparse" version of categorical_crossentropy
# because our target data is integers.
# original loss = "sparse_categorical_crossentropy" from keras doesn't work, it works if set to "categorical_crossentropy"

import tensorflow as tf
from keras.optimizers import SGD, Adam

loss = tf.keras.losses.CategoricalCrossentropy(
    from_logits=True, label_smoothing=0.01, reduction = "auto",
    name='categorical_crossentropy') 

adam = Adam(lr=1e-6, decay=1e-5)
#model.compile(loss=loss, optimizer = 'rmsprop', loss = loss, metrics=['categorical_crossentropy']) # solution from stackoverflow
model.compile(optimizer=adam, loss= 'categorical_crossentropy')

callbacks = [
    keras.callbacks.ModelCheckpoint("oxford_segmentation.h5", save_best_only=True,  save_freq = 'epoch')
]

# Train the model, doing validation at the end of each epoch.
# Use epochs 60 for first time
epochs = 10
history = model.fit(train_gen, epochs=epochs, validation_data=val_gen, callbacks= callbacks, verbose=1)

# save the model in .h5 format
model.save(os.path.join(model_lib, "keras_unet_test.h5"))

# visualize training and validataion loss by epochs
import matplotlib.pyplot as plt
fig = plt.figure()
plt.plot(history.history['loss'], label='loss')
plt.plot(history.history['val_loss'], label = 'val_loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
#plt.ylim([0, 1])
plt.legend(loc='upper right')

4. model training 完成，现在可以开始测试了

import os
from tensorflow.keras.models import load_model
model = load_model(os.path.join(model_lib, "keras_unet_test.h5"))

import cv2
import numpy as np
from tensorflow.keras.preprocessing import image


img_name = 'butterfly(55)_90.png'

# load the image and convert image to array
img = cv2.imread(os.path.join(input_dir, img_name),3)
img = cv2.resize(img, (128, 128)) 
img1 = image.img_to_array(img)/255
img1 = np.expand_dims(img, axis=0)

pred_score = model.predict(img1, batch_size = 1)

Note : 这里需要注意一下。pred_score 的 value 还需要进行进一步的处理，才能够弄出 segmentized 图片，以下有两个方法可以弄。第一个就是用 np.argmax()，这个方法不能够 set threshold value，所以搞出来的 segmentation 不是很好。另一个方法比较 manual ，但好处是可以自己 set threshold value，可以调出较好的 segmentation

# preprocess the predicted result
# method 1 : without threshold adjustment
mask = np.argmax(pred_score, axis = 3)
mask = ((mask==1)).astype(np.uint8)

#pred_score*255
pred_bool = pred_score > 0.8
pred_bin = pred_bool

mask = np.argmax(pred_bin, axis = 3)
mask

# plot the mask and image
import matplotlib.pyplot as plt
f = plt.figure(figsize=(10,10))
f.add_subplot(1,2, 1)
plt.imshow(np.squeeze(mask[0]), cmap = 'gray')
f.add_subplot(1,2, 2)
plt.imshow(img, cmap = 'gray' )
plt.show(block=True)

# plot image and overlay image
masked = np.ma.masked_where(mask == 1, mask)

import matplotlib.pyplot as plt
plt.figure(figsize=(10,10))
plt.subplot(1,2,1)
plt.imshow(img, 'gray', interpolation='none')
plt.subplot(1,2,2)
plt.imshow(img, 'gray', interpolation='none')
plt.imshow(masked[0], 'jet', interpolation='none', alpha=0.7)
plt.show()

ok, 完事，以下是我两个星期来研究这 semantic segmentation 的结果。其实，从 mask 的 array，只要把 1 的总数加起来，就可以知道那 segment 的 pixel 数目，有了这个数据，我就可以把它转换为面积，或是用来计算物体的 dimension。谁说 deep learning 不能做 dimension check

Semantic Segmentation

noreply@blogger.com (I Talk - You Do) — Fri, 15 Oct 2021 13:03:00 +0000

说起 Semantic Segmentation 这个玩意啊，其实我早有听说，但是一直都没有吧这门技术给学上来。主要原因还是在过去一年多的时间我都在传统的 image classification 和 object detection 上打转。完了一年多的 VGG16, Resnet, EfficientNet 和 faster RCNN。如果要我解释这几个 network 的架构，基本上我是解释不出来的，但。。。我还是能够利用这些 pretrained 模型来组装出一套我想要的 image classification solution。

前阵子学习用 CNN 来做 time series 的时候已经告诉过自己，完成了 time series 之后，无论如何都得把 Semantic Segmentation 这门技术给学上来。因为这技术在 computer vision 和 self driving car 扮演着重要的角色。既然我想专注在 computer vision 这一块，那么我必须把这一门技术给学好。

今天偷了公司一整天的时间在扒网，终于都给我找到了个好东西。一个对我来说不太难使的 Semantic Segmentation 工具。

https://pixellib.readthedocs.io/en/latest/Image_instance.html

至于那些 code，都可在 pixellib 的网页上找到，我这里就不再多此一举了。试玩了一下。

看看我今年弄出来的成品，还行

好，今天算是一个开始，接下来的日子就是要好好研究这 pixellib 的工具了。

Detect Approaching Object With Time Series Model

noreply@blogger.com (I Talk - You Do) — Sat, 02 Oct 2021 03:44:00 +0000

上一次学习了 Time Series model 之后，激发了我一个好奇心，是不是我也可以使用这个 Time Series model 的原理来开发一个车距警报系统。只要 model 侦察到前面的物体越来越大，那么 AI 就会提升司机注意前方行车距离。

我用了之前学到的 code 做了一个小小的实验，理论上是可以的。

一下就是我整理出来的构思，收着先，看哪天有空我才来完成整个 solution

How To Build Multivariate Multi-Step Time Series CNN Models

noreply@blogger.com (I Talk - You Do) — Sun, 26 Sep 2021 02:43:00 +0000

几天前把这 multivariate multi-step 1d cnn time series 的方法弄好，乘这周末的早上把资料整理好，要不，又会有一大堆借口跳出来堵住自己前进的去路。今天还是觉得有点懒，所以也不多说，就只上载我之前弄好的 code 就罢。


# ref : https://machinelearningmastery.com/how-to-develop-convolutional-neural-network-models-for-time-series-forecasting/
# multivariate multi-step 1d cnn example
from numpy import array
from numpy import hstack
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers.convolutional import Conv1D
from keras.layers.convolutional import MaxPooling1D
import pandas as pd

# split a multivariate sequence into samples

def split_sequences(sequences, n_steps_in, n_steps_out):
    X, y = list(), list()
    for i in range(len(sequences)):
        # find the end of this pattern 
        end_ix = i+n_steps_in
        out_end_ix = end_ix + n_steps_out - 1
        #check if we are beyong the dataset 
        if out_end_ix > len(sequences):
            break 
        # gather input and output parts of the pattern
        seq_x, seq_y = sequences[i:end_ix, :-1], sequences[end_ix-1:out_end_ix, -1]
        X.append(seq_x)
        y.append(seq_y)
        
    return array(X), array(y)

# define input sequence 
in_seq1 = array([10, 20, 30, 40, 50, 60, 70, 80, 90])
in_seq2 = array([15, 25, 35, 45, 55, 65, 75, 85, 95])
out_seq = array([in_seq1[i]+in_seq2[i] for i in range(len(in_seq1))])

# convert to [row, columns] structure
in_seq1 = in_seq1.reshape((len(in_seq1), 1))
in_seq2 = in_seq2.reshape((len(in_seq2), 1))
out_seq = out_seq.reshape((len(out_seq), 1))

# horizontally stack columns
dataset = hstack((in_seq1, in_seq2, out_seq))

# choose a number of time steps
n_steps_in, n_steps_out = 3, 3

# convert into input/output
X, y = split_sequences(dataset, n_steps_in, n_steps_out)
n_features = X.shape[2]

print(X.shape, y.shape)
# summarize the data
for i in range(len(X)):
    print(X[i], y[i])

设定 CNN model

# define model
model = Sequential()
model.add(Conv1D(filters=64, kernel_size=2, activation='relu', input_shape=(n_steps_in, n_features)))
model.add(MaxPooling1D(pool_size=2))
model.add(Flatten())
model.add(Dense(50, activation='relu'))
model.add(Dense(n_steps_out))
model.compile(optimizer='adam', loss='mse')# fit model
model.fit(X, y, epochs=2000, verbose=0)

好了，可以测试刚 train 好的 model 了

# demonstrate prediction
x_input = array([[70, 75], [80, 85], [90, 95]])
x_input = x_input.reshape((1, n_steps_in, n_features))
yhat = model.predict(x_input, verbose=0)
print(yhat)

ok, 完事。

这里可以总结一下，这三个星期来我学了一下三个 time series 的方法。

1. How To Build A Univariate Time Series CNN Models

2. How To Multivariate Time Series CNN Models

3. Multivariate Multi-Step Time Series CNN Models

这三个方法对我来说还蛮实用的，接下来，就是想要如何运用这新学到的方法了。

How To Build Multivariate Time Series CNN Models

noreply@blogger.com (I Talk - You Do) — Sun, 12 Sep 2021 13:35:00 +0000

上个周末学会了 Univariate CNN Models，这个周末就得逼自己学会 Multivariate CNN Model 了

以下是从参考资料那来复制过来的码，试过了，行得通。可以留着自己用。

# ref : https://machinelearningmastery.com/how-to-develop-convolutional-neural-network-models-for-time-series-forecasting/

# multivariate data preparation 
from numpy import array
from numpy import hstack
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers.convolutional import Conv1D
from keras.layers.convolutional import MaxPooling1D
import pandas as pd

# split a multivariate sequence into samples
def split_sequences(sequences, n_steps):
    X,y = list(), list()
    for i in range(len(sequences)):
        # find the end of the pattern
        end_ix = i + n_steps
        # check if we are beyong the dataset
        if end_ix > len(sequences):
            break
        # gather input and output parts of the pattern 
        seq_x, seq_y = sequences[i:end_ix, :-1], sequences[end_ix - 1, -1]
        X.append(seq_x)
        y.append(seq_y)
        
    return array(X), array(y)

# if data is stored in external file in csv format
# read data file
data = pd.read_csv('data_m.csv')
data

in_seq1 = data['x1'].to_numpy()
in_seq2 = data['x2'].to_numpy()
out_seq = data['y'].to_numpy()


# convert to [row, columns] structure
in_seq1 = in_seq1.reshape((len(in_seq1),1))
in_seq2 = in_seq2.reshape((len(in_seq2),1))
out_seq = out_seq.reshape((len(out_seq),1))

# horizontally stack columns
dataset = hstack((in_seq1, in_seq2, out_seq))
dataset 

# if you don't have data stored in external file in csv format
# define input sequence 
in_seq1 = array([10, 20, 30, 40, 50, 60, 70, 80, 90])
in_seq2 = array([15, 25, 35, 45, 55, 65, 75, 85, 95])
out_seq = array([in_seq1[i]+in_seq2[i] for i in range(len(in_seq1))])

# convert to [row, columns] structure
in_seq1 = in_seq1.reshape((len(in_seq1),1))
in_seq2 = in_seq2.reshape((len(in_seq2),1))
out_seq = out_seq.reshape((len(out_seq),1))

# horizontally stack columns
dataset = hstack((in_seq1, in_seq2, out_seq))
dataset

设定 CNN model

# define model
model = Sequential()
model.add(Conv1D(filters=64, kernel_size=2, activation='relu', input_shape=(n_steps, n_features)))
model.add(MaxPooling1D(pool_size = 2))
model.add(Flatten())
model.add(Dense(50, activation='relu'))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')# fit model
model.fit(X,y, epochs = 1000, verbose = 0)

好了，可以测试刚 train 好的 model 了

# demonstrate prediction 
x_input = array([[80,85], [90,95], [100,105]])
x_input = x_input.reshape((1,n_steps, n_features))
yhat = model.predict(x_input, verbose=0)
print(yhat)

ok, 完事。

How To Build A Univariate Time Series CNN Models

noreply@blogger.com (I Talk - You Do) — Sun, 05 Sep 2021 14:04:00 +0000

刚开始接触 CNN 主要是为了开发图像识别机器人，这一年来花了不少的时间研究了几个不同的 CNN，都是离不开图像识别。其实，除了图像识别，CNN 在 predictive analytic 方面还大有用途的。

今天，我就来学习如何使用 CNN 来做 Time Series Forecasting model。

这是我从 Google 搜回来的参考资料：How to Develop Convolutional Neural Network Models for Time Series Forecasting

这 tutorial 讲解了四种不同的 time series forecast 的方式

1. Univariate CNN Models

2. Multivariate CNN Models

3. Multi-Step CNN Models

4. Multivariate Multi-Step CNN Models

今天就学习 Univariate CNN Models 就好，其他三个就一步一步来。

以下是从参考资料那来复制过来的码，试过了，行得通。可以留着自己用。

# ref : https://machinelearningmastery.com/how-to-develop-convolutional-neural-network-models-for-time-series-forecasting/

# univariate data preparation 
from numpy import array
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers.convolutional import Conv1D
from keras.layers.convolutional import MaxPooling1D

# split a univariate sequence into samples
def split_sequence(sequence, n_steps):
    X, y = list(), list()
    for i in range(len(sequence)):
        # find the end of this pattern 
        end_ix = i + n_steps
        # check if we are beyond the sequnce 
        if end_ix > len(sequence)-1:
            break
        # gather input and output parts of the pattern
        seq_x, seq_y = sequence[i:end_ix], sequence[end_ix]
        X.append(seq_x)
        y.append(seq_y)
        
    return array(X), array(y)

# may use this code if data is stored in an external csv file
# read data file
raw_sqe = pd.read_csv('data.csv')
# convert pandas datafrom to numpy array
raw_seq = raw_sqe['data'].to_numpy()


# define input sequence
raw_seq = [10,20,30,40,50,60,70,80,90]
# choose a number of time steps
n_steps = 3
# split into samples
X,y = split_sequence(raw_seq, n_steps)
# summarize the data
for i in range(len(X)):
    print(X[i], y[i])

接下来是设定好 CNN 的模型

# reshape from [samples, timesteps] into [samples timesteps, features]
n_features = 1
X = X.reshape((X.shape[0], X.shape[1], n_features))

# deine model
model = Sequential()
model.add(Conv1D(filters=64, kernel_size = 2, activation='relu', input_shape = (n_steps, n_features)))
model.add(MaxPooling1D(pool_size = 2))
model.add(Flatten())
model.add(Dense(50, activation = 'relu'))
model.add(Dense(1))

model.compile(optimizer = 'adam', loss = 'mse')

做 model training，如果想看 training accuracy 和 loss 的话，可以把 verbose set 去 1

# fit model
model.fit(X,y, epochs = 1000, verbose = 0)

好了，可以测试刚 train 好的 model 了

# demonstraate prediction 
x_input = array([60, 70, 80])
x_input = x_input.reshape((1, n_steps, n_features))

yhat = model.predict(x_input, verbose = 1)
print(yhat)

好了，就这样先，至少没虚度这个周末

How To Build AutoEncoder For Abnormally Detection

noreply@blogger.com (I Talk - You Do) — Sat, 31 Jul 2021 08:39:00 +0000

前阵子忙着测试 image classification model 的 solution，忙得没日没夜，牺牲了好几个睡眠。终于，有时间停下来喘口气，然后继续出发。之前也一直提醒自己，在这竞争激励的环境，我不能只是停留在 image classification 这一块，还有很多 computer vision 的技术等着我去提升。所以，这两个星期来，花了不少的时间研究了个 abnormally detection 的方法，那就是 autoencoder。

其实 autoencoder 这门技术我早在一年前听伟伦提过，但由于当时专注在 image classification 这一块，所以也没有认真的去看待。今天，无论如何都要把这技术学上来。

Autoencoder 又是什么东东？Autoencoder 一般由三个重要的 component 组成， Encoder，Latent / Code 和 Decoder。当我们把一张图片输入进一个已经 train 好的 encoder，图片数据经过这个 encoder 变成一个 code 的时候，当中会有一些 data loss。如果我们再把这 code decode 回去的话，那么那个 loss 就会更大，因此，我们可以利用这个 data loss 来做个预测，那输入的图片是否是个 outlier 或是 abnormality 。

如果输入的图片和 training data 的图片相似，那么图片进入 encoder 和 decode 出去所造成的 loss 都会比较低。只要比较一下 encoder 和 decoder 的 mse，就可以做个预测。就这样简单。

Auto encoder 是一个 unsupervised ai model，所以，在准备 training data set 方面和 image classification model 不一样。它只需要一个 class 的 dataset 就行了。

花了连个多星期在网上扒资料，说真的，我实在是找不到一个完整的 tutorial，大部分的 tutorial 都是用网上现成的 mnist 的 training data set 来做，但是如果想要用自己的 data set 来 train 的话，其实还得下点功夫才行。我也是读了好几个人的 tutorial，把他们的示范贴贴剪剪的，才完成了一个我自己想要的 auto encoder 。

好了，一下就是我自己凑成的 auto encoder ，这里，我用的是自己的 training dataset。我的 training dataset 差不多是这一个样子的。

过后我们可以尝试用这张图片来测试那个 auto encoder ，看看结果会是什么。

好，就来看看我的 code 吧。

# https://www.pyimagesearch.com/2020/03/02/anomaly-detection-with-keras-tensorflow-and-deep-learning/
# https://python.tutorialink.com/match-dtypes-of-one-df-to-another-with-different-number-of-columns/

# import the necessary packages
from tensorflow.keras.layers import BatchNormalization
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import Conv2DTranspose
from tensorflow.keras.layers import LeakyReLU
from tensorflow.keras.layers import Activation
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Reshape
from tensorflow.keras.layers import Input
from tensorflow.keras.models import Model
from tensorflow.keras import backend as K

import tensorflow.keras
from tensorflow.keras.optimizers import Adam

import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import argparse
import random
import pickle
import cv2

# Set working directory

import os
base_dir_path = "pkg_object\\"
train_dir_path = os.path.join(base_dir_path,'training')
test_dir_path = os.path.join(base_dir_path,'testing')
unlabel_image_dir = os.path.join(base_dir_path,'unlabel_image')
result_dir = os.path.join(base_dir_path,'result')
template_dir = os.path.join(base_dir_path,'template_1')
image_dir = os.path.join(base_dir_path,'images')
model_lib_dir = os.path.join(base_dir_path,'model_library')

一下这段是从这里抄回来的

# build the autoencoder
# 3 key parameter need to take note : filters and latenDim
# width: Width of the input images.
# height: Height of the input images.
# depth: Number of channels in the images.
# filters: Number of filters the encoder and decoder will learn, respectively
# latentDim: Dimensionality of the latent-space representation.

class ConvAutoencoder:
    @staticmethod
    def build(width, height, depth, filters=(32, 64), latentDim=16):
        # initialize the input shape to be "channels last" along with
        # the channels dimension itself
        # channels dimension itself
        inputShape = (height, width, depth)
        chanDim = -1
        
        # define the input to the encoder
        inputs = Input(shape=inputShape)
        x = inputs
        
        # loop over the number of filters
        for f in filters:
            # apply a CONV => RELU => BN operation
            x = Conv2D(f, (3, 3), strides=2, padding="same")(x)
            x = LeakyReLU(alpha=0.2)(x)
            x = BatchNormalization(axis=chanDim)(x)
            
        # flatten the network and then construct our latent vector
        volumeSize = K.int_shape(x)
        x = Flatten()(x)
        latent = Dense(latentDim)(x)
        
        # build the encoder model
        encoder = Model(inputs, latent, name="encoder")
        
        # start building the decoder model which will accept the
        # output of the encoder as its inputs
        latentInputs = Input(shape=(latentDim,))
        x = Dense(np.prod(volumeSize[1:]))(latentInputs)
        x = Reshape((volumeSize[1], volumeSize[2], volumeSize[3]))(x)
        
        # loop over our number of filters again, but this time in
        # reverse order
        for f in filters[::-1]:
            # apply a CONV_TRANSPOSE => RELU => BN operation
            x = Conv2DTranspose(f, (3, 3), strides=2,padding="same")(x)
            x = LeakyReLU(alpha=0.2)(x)
            x = BatchNormalization(axis=chanDim)(x)
            
        
        # apply a single CONV_TRANSPOSE layer used to recover the
        # original depth of the image
        x = Conv2DTranspose(depth, (3, 3), padding="same")(x)
        outputs = Activation("sigmoid")(x)
        
        # build the decoder model
        decoder = Model(latentInputs, outputs, name="decoder")
        
        # our autoencoder is the encoder + decoder
        autoencoder = Model(inputs, decoder(encoder(inputs)),name="autoencoder")
        
        # return a 3-tuple of the encoder, decoder, and autoencoder
        return (encoder, decoder, autoencoder)

一下这段是参考 stack overflow 里面的解答，再从新修改的

SHAPE = (52,52)
EPOCHS = 30
INIT_LR = 1e-4
BS = 32

(encoder, decoder, autoencoder) = ConvAutoencoder.build(52,52,1)
opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
autoencoder.compile(loss="mse", optimizer=opt)


from keras.preprocessing.image import ImageDataGenerator
image_generator = ImageDataGenerator(rescale=1.0/255.0) # normalize the data by deviding with 255
train_gen = image_generator.flow_from_directory(
    os.path.join(base_dir_path, "train_ad"), 
    class_mode='input', target_size=SHAPE, batch_size=BS,
    color_mode="grayscale",
)
val_gen = image_generator.flow_from_directory(
    os.path.join(base_dir_path, "test_ad"), 
    class_mode='input', target_size=SHAPE, batch_size=BS,
    color_mode="grayscale",
)

# check autoencoder model summary
autoencoder.summary()


Model: "autoencoder"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_3 (InputLayer)         [(None, 52, 52, 1)]       0         
_________________________________________________________________
encoder (Model)              (None, 16)                192272    
_________________________________________________________________
decoder (Model)              (None, 52, 52, 1)         239937    
=================================================================
Total params: 432,209
Trainable params: 431,825
Non-trainable params: 384
_________________________________________________________________

# start autoencoder training

history = autoencoder.fit(train_gen, validation_data=val_gen,epochs=EPOCHS,batch_size=BS)

# plot the training & validation loss by epoch
fig = plt.figure()
plt.plot(history.history['loss'], label='loss')
plt.plot(history.history['val_loss'], label = 'val_loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
#plt.ylim([0, 1])
plt.legend(loc='lower right')

#plt.savefig('1st_bond_model_train_result.png')
#plt.close(fig)

<matplotlib.legend.Legend at 0x2bf62bdb780>

# save the autoencoder model
autoencoder.save("autoencoder.h5")

好了，model 已经 train 好，接下来是测试的时候了。我们得先把 model 给 load 出来

# load autoencoder model for application 

from numpy import loadtxt
from keras.models import load_model
autoencoder = load_model('autoencoder.h5')

我先输入这张图，这张图和 training data set 得图相似，我先看看结果

# load an image to test the auto encoder 
import cv2
import os
images = cv2.imread(os.path.join(base_dir_path, '1.png'),0)
img = cv2.resize(images, (52, 52))
#img = images.img_to_array(img)
img = np.expand_dims(img, axis=0)/255

# show the test sample
plt.imshow(images, cmap='gray')

<matplotlib.image.AxesImage at 0x2bf65910c18>

# make predictions on our image data and initialize our list of
# reconstruction errors
decoded = autoencoder.predict(img)
mse = np.mean((img - decoded) ** 2)
mse

0.01824960274209594

以上得答案显示， encode - decode = 0.018

decode 出来的图片是这样的，失真了不少。

# show the decoded image
plt.imshow(decoded[0], cmap='gray')

<matplotlib.image.AxesImage at 0x2bf659717b8>

好，现在我换上之前说好的测试图片，看看结果怎么样

# load an image to test the auto encoder 
import cv2
import os
images = cv2.imread(os.path.join(base_dir_path, 'h_113_other.png'),0)
img = cv2.resize(images, (52, 52))
#img = images.img_to_array(img)
img = np.expand_dims(img, axis=0)/255

# show the test sample
plt.imshow(images, cmap='gray')

<matplotlib.image.AxesImage at 0x2bf659be208>

# make predictions on our image data and initialize our list of
# reconstruction errors
decoded = autoencoder.predict(img)
mse = np.mean((img - decoded) ** 2)
mse

0.09731018653693392

这一次，encode - decode = 0.097，这个 MSE 比之前的大很多，所以我们可以凭这个 MSE 来预测这是个 abnormality 或是 outlier

这是 decode 出来的结果

# show the decoded image
plt.imshow(decoded[0], cmap='gray')

<matplotlib.image.AxesImage at 0x2bf65a30400>

ok, 今天为自己上了一课，又长知识了。

Sunday

noreply@blogger.com (I Talk - You Do) — Sun, 18 Jul 2021 04:40:00 +0000

已经三个月没有在这里趴格子了。今天，总算有时间上来 update 一下差点被我遗弃的部落格。

这三个月来，花了大部分时间在测试第一个自己开发 visual inspection AI system。三个月的不眠不休，经过无数次的测试和优化，终于对自己的成品有了一定的信心，放心的停下来喘口气，好好的休息休息再出发。

这个 AI 系统，我足足花了两年多的时间把它给搞出来，是我人生中第一个自己搞出来的 AI 系统。两年的时间对那些专业数据科学家来说或许太长了，但对我这个初学者来说，可是花了很大的努力才得到的成果。

记得两年前的一窍不通，就这样开始了 computer vision 的这个艰难路程。就这样开始在 Google 上搜索阅相关资料。It's that easy! Image classification with keras in roughly 100 lines of code. （Shirin's playgRound) 是我在学习 computer vision 技术的第一课，也是最重要的一课。上面提过的 AI 系统其实就是根据她的示范演变而成。

这两年来的亲历亲为，让我掌握了 image classification， object detection 和 image pre processing 的窍门，总结起来，这两年来也收获不少。

当然，AI 是个万变的领域，我无法停留在现阶段。接下来的日子应该会有较多的空挡，也是时候弥补自己在这方面的不足。比如说 Semantic Image Segmentation，Yolo 还有一些更加深奥的数据运算技术。这些都需要大大的提升。

加油吧。。。

How to intall LabelImg in Anaconda Virtual Environment

noreply@blogger.com (I Talk - You Do) — Sat, 24 Apr 2021 13:40:00 +0000

两个礼拜前工作用的电脑因为一个 windows update, file explore 出现了一些小问题。昨天屁股痒打电话去 IT 部门求解，结果被 IT 技师那么一弄，弄出了一个更大的问题。Webex 进不了，没有了 Webex，就是说公司上上下下的同事都联络不上，会议也开不了。

技师说，没办法了，需要 format hard disk，这才是灾难啊。。。。

真不敢想象，下个星期拿回电脑后，需要从新安装那些 AI model training 必备 package，之前写的那些 model training script 能不能够顺利的在新电脑上跑，还是个未知数。

既然从新开始是免不了了，另一方面，之前在不熟悉 Python 和 Anaconda 的情况下，胡乱了安装了不少的 package，这一次的从新安装，给了我一个机会整理整理我的 conda environment。

因此，今天下午闲来无事，就拿起家里一台新电脑，尝试安装了 Anaconda 和 labelimg。试看是否能够顺利安装。记得之前安装 labelimg 的时候并不是那么顺利的。其实今天安装 labelimg 的时候也不是那么的顺利，幸好最终还是成功完成。

看来，我需要把这些安装过程记录好来，好让我日后有个参考。

拿到新电脑第一件事就是要安装 Anaconda。这个安装不难，上 Anaconda 的网站 download 就行了，基本上不会面对什么大问题。

接下来就是安装 labelimg 了。记得第一安装这个应用软件的时候碰了好多的钉子，所以我觉得应该要把安装过程给记录下来，以备往后需要用到。

以下是我安装 label image 的过程（这个方法成功在其他同事电脑上安装了 labelimg)

1. 打开 Anaconda。去 Environment >> Create 开一个新的 virtual environment 叫 labelimg

2. 按 labelimg 右边的箭头，选 open terminal。一个新的 virual environment 就会跳出来。

3. 按次序安装一下的 package，在这新电脑里能够顺利的完成

pip3 install labelimg

labelimg

好，希望下星期安装这 package 在新电脑也能够顺利。

How To Build An Custom Object Detection Model With Open CV & EfficientNet

noreply@blogger.com (I Talk - You Do) — Sat, 17 Apr 2021 10:49:00 +0000

之前分享过如何用 Detecto 这个 package 来弄 custom object detection model。原来这 Detecto 后面使用的是 Faster RCNN 的架构，可以说是个相当大的 neural network，所以在 model training 方面会相当吃力。需要动用到 Colab。而且也不容易处理。

由于近来再用 Detecto 来 optimized 之前那个案子，结果，怎么弄，都弄不回像 model rev 1 那么准确。白白浪费了不少的时间，最终决定放弃，Detecto 这个方法，从新设计另外一个 object detection 的方法。

这一，我选择了简单的方法，

1. 先用 open cv 做些图像处理，把原来图片转换成 binary

2. 再用 open cv find contour 功能把 contour 挑出来

3. 把 contour 从图片里 crop 出来，然后传给一个 image classification model 来做进一步的分类。

4. 最后，根须 prediction 的 softmax value 来找出所要的 custom object。

这个方法比较简单，而且不需要动用到 GPU。

好，接下来我就来谈谈创造这个 object detection 的过程

第一个步骤

就是准备 training 和 testing data set。不相之前用 Detecto 那样，用 labelimg 画 bounding box 画到半死，这里我用了 open cv 的 find contour，两下半就把需要的 training & testing dataset 给弄出来。过后把那些 contour 分类成两个 class 就可以了。

一下是把 contour crop 出来的 code

# load required library
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
import os
import cv2
import pandas as pd

2. set working directory

# set working directory
base_dir_path = "."
image_dir = os.path.join(base_dir_path,'img_dir')
unlabeled_img = os.path.join(base_dir_path,'unlabeled_img')
results_dir = os.path.join(base_dir_path,'results')

3. 先把图像 load 出来，然后转换成 binary format

# read all image from image directory & convert the image to binary format
img_rgb = cv2.imread(os.path.join(image_dir,"sample_img.jpg"),0)
img_blur = cv2.blur(img_rgb, (2, 2))
ret, img_thr = cv2.threshold(img_blur, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)

plt.figure(figsize = (14,8))
plt.imshow(img_thr,cmap='gray')

4. 最后就是用这个 script 把 contour 的 coordinate 找出来，然后利用这些 data 把所有 contour crop 出来，save 再 unlabeled image folder 里面。

# find the contour
contours, hierarchy = cv2.findContours(img_thr,cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[-2:]

# store all bounding box data into a data frame name df
image = img_rgb
i = 1
for c in contours:
    x, y, w, h = cv2.boundingRect(c)
            
# Make sure contour area is large enough
                #if (cv2.contourArea(c)) < 500 and (cv2.contourArea(c)) > 9:
    contour_img = img_rgb[(int((y+h/2)-25)):(int((y+h/2)+25)), (int((x+w/2)-25)):(int((x+w/2)+25))]
    
    cv2.imwrite(os.path.join(unlabeled_img, str(i)+"contour_img.jpg"), contour_img)
    i = i + 1

这就是刚 crop 出来的 sample image。接下来需要一些 manual sorting 来把“是”或是 “不是”星星图像分类出来存进 training 和 testing data set 里面的 sub folder 里。

第二个步骤就是做 model training 了。由于 find contour 只能够帮我们挑出类似物体的形状，但是我们好不能够确定那个物体到底是不是我们像要找的物体。所以，我们需要用从 binarized image 所得到的 coordinate，然后回去原来的图像，把同样的点给 crop 出来，再传给一个 image classifier 来做进一步的分析。

因此，我需要用步骤一所得到的图像来 train 一个 image classifier 出来。这里我选用了 EfficientNetB0 来 train 我的 image classification model。

以下是 image classification model training 的 code

1. 把需要用到的 library 给 load 出来

#ref : https://analyticsindiamag.com/implementing-efficientnet-a-powerful-convolutional-neural-network/

import os
import cv2
import traceback
import numpy as np
import pandas as pd

import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from PIL import Image

from keras.preprocessing.image import ImageDataGenerator
from keras.optimizers import SGD, Adam
from keras.callbacks import ReduceLROnPlateau
from keras.layers import Flatten, Dense, BatchNormalization, Activation, Dropout
from keras.utils import to_categorical

from keras import Sequential
import keras_efficientnets
from keras_efficientnets import EfficientNetB0
from keras_efficientnets import custom_objects


import tensorflow as tf
from tensorflow.keras.losses import CategoricalCrossentropy
from tensorflow.keras.preprocessing import image

from keras import layers
from keras.layers import MaxPooling2D

2. Define working directory

# Set working directory
base_dir_path = "."
train_dir_path = os.path.join(base_dir_path,'training')
test_dir_path = os.path.join(base_dir_path,'testing')

3. Define 那些需要用到的 function （其实这些 function 我也不太懂，都是网上抄回来的）

def getAllClassNames(dir_path):
    return os.listdir(dir_path)


# get a list of all class. use the def function above
AllClassNames = getAllClassNames(train_dir_path)

# check number of class in the training directory
num_of_classes = len(AllClassNames)

# build dict of class_id and classname
DictOfClasses = {i : AllClassNames[i] for i in range(0, len(AllClassNames))}

print(AllClassNames)
print(num_of_classes)
print(DictOfClasses)

Output

['dust', 'others']
2
{0: 'dust', 1: 'others'}

3. 设定 EfficientNetB0 的 model，一般我们都是用 softmax value

# setup the EfficientNetB0 pretrained model
conv_base = EfficientNetB0(include_top = False, weights = "imagenet", input_shape = (50,50,3))
conv_base.trainable = True

model = Sequential()
model.add(conv_base)
model.add(layers.GlobalMaxPooling2D())
model.add(layers.Dropout(0.5))  
model.add(Dense(num_of_classes,activation='softmax'))

#Checking the final model summary
model.summary()

Output

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
model (Model)                (None, 2, 2, 1280)        4049564   
_________________________________________________________________
global_max_pooling2d (Global (None, 1280)              0         
_________________________________________________________________
dropout (Dropout)            (None, 1280)              0         
_________________________________________________________________
dense (Dense)                (None, 2)                 2562      
=================================================================
Total params: 4,052,126
Trainable params: 4,010,110
Non-trainable params: 42,016

5. 做 model compilation，这里可以做一些 hyperparameter 的 setting，比如 learning rate, decay

# compile the model
optimizer = Adam(lr=1e-4, decay=1e-6)

loss = tf.keras.losses.CategoricalCrossentropy(
    from_logits=False, label_smoothing=0.066, reduction = "auto",
    name='categorical_crossentropy') 

model.compile(optimizer=optimizer,
               loss=loss,
               metrics=['accuracy'])

2. Setup data generator

# setup the data generator

# data augmentation 
datagen = ImageDataGenerator(rescale=False,
                             shear_range=0.4,
                             zoom_range=0.2,
                             rotation_range=30,
                             width_shift_range=0.2,
                             height_shift_range=0.2,
                             horizontal_flip=True,
                             #fill_mode='nearest'
                            )

batch_size = 120

# instruct the program to flow through all sub folder in train data set
train_generator = datagen.flow_from_directory(
        train_dir_path,  # this is the target directory
        target_size=(50, 50),  # all images will be resized to 50x50
        batch_size=batch_size,
        seed = 1, 
        class_mode='categorical')

# instruct the program to flow through all sub folder in test data set
test_generator = datagen.flow_from_directory(
        test_dir_path,  # this is the target directory
        target_size=(50, 50),  # all images will be resized to 50x50
        batch_size=batch_size,
        seed = 1,
        class_mode='categorical')

6. 可以开始做 model training 了。正常情况下需要用到大约一个小时的时间才能完成这个步骤。时间长短需要看 data set 的情况，和 epochs 的设定。如果 Output 那里继续有新的 data 出来，就证明 model training process 正常操作。最后的 accuracy 和 val_accuracy 都必须再 0.95左右，而且两者都必须要相当接近。如果两者之间有一个很大的差异，也就是说这个 model 有 over fitting 或是 under fitting 的问题。

根据我的经验，不建议把 model accuracy fit 得太过接近 1。太过 over fit 反而会制造另外一个问题。刚刚好就 ok 。

刚从伟伦大师那里学到，如果没有输入 verbose=1，那么下面的 output 就不会显示出来。

# make sure no over fitting
history = model.fit_generator(train_generator,
                          epochs=50,
                          validation_data = test_generator,
                          verbose=1)

Epoch 1/50
9/9 [==============================] - 26s 3s/step - loss: 0.8418 - accuracy: 0.7009 - val_loss: 0.9897 - val_accuracy: 0.6185
Epoch 2/50
9/9 [==============================] - 23s 3s/step - loss: 0.5739 - accuracy: 0.8103 - val_loss: 0.9142 - val_accuracy: 0.5636
Epoch 3/50
9/9 [==============================] - 24s 3s/step - loss: 0.5079 - accuracy: 0.8683 - val_loss: 0.7216 - val_accuracy: 0.5549

7. OK，一个 model training 就这样完成（如果一切顺利的话）。好接下来可以把 accuracy 和 validation accuracy data 给弄出来做个分析。

# convert history data into a data frame
pd.DataFrame(history.history)

# Plot accuracy vs epochs and save the chart in  local 
fig = plt.figure()
plt.plot(history.history['accuracy'], label='accuracy')
plt.plot(history.history['val_accuracy'], label = 'val_accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.ylim([0.5, 1])
plt.legend(loc='lower right')

plt.savefig('test_123.png')
plt.close(fig)

图下可以看到 model accuracy vs epochs 的过程。从这张图看来，这个 image classification model training 的发展还属于正常的。开始的时候是有一些 under fitting 的问题，但是问题在 epochs = 50 的时候有些改善。其实可以把 epochs 加大到 60，从新 train 多一次，看看那两条线是否继续走到很近。还是会再某个 epochs 又开始分叉。我们可以用这样得方法来决定最 optimize 的 epochs。

8. 最后，把 train 好的 model 存起来。接下来的 deployment 需要用到。(需要事先在 base_dir_path 那里开一个 model_library 的 folder)

model.save('C:/Users/xxx/Desktop/char_finding/model_library/dust_effnetB0_rev1.h5')

现在要做最后一个步骤了。这里要做的就是整合整个 object detection 的流程。

1. 在 base_dir_path 那里开两个新的 folder

2. 把需要用到的 library 给 load 出来

# load required library
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
import os
import cv2
import traceback
import itertools
import pandas as pd
import tensorflow as tf
from keras_efficientnets import EfficientNetB0

2. Define working directory

# set working directory
base_dir_path = "."
image_dir = os.path.join(base_dir_path,'img_dir')
unlabeled_img = os.path.join(base_dir_path,'unlabeled_img')
results_dir = os.path.join(base_dir_path,'results')

3. 把之前 train 好的 image classification model load 出来

from tensorflow.keras.models import load_model
model = load_model('C:/Users/xxx/Desktop/char_finding/model_library/dust_effnetB0_rev1.h5')

4. 以下的 code 会自动去读取在 img_dir folder 的图像，然后进行分析。分析后的图像会存在 results folder 里。

datalist = []

try:
# read image from image_dir
    for filename in os.listdir(image_dir):
        if filename.endswith(".jpg") :
            img_rgb = cv2.imread(os.path.join(image_dir, filename),0)
        
# image processing start        
            img_blur = cv2.blur(img_rgb, (2, 2))
            ret, img_thr = cv2.threshold(img_blur, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)
        
# define structuring element
            #rect_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (50, 50))
    
# use contours to detect the character
            contours, hierarchy = cv2.findContours(img_thr,cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[-2:]
        
# Dust classification 
# store all bounding box data into a data frame name df
            image = img_rgb
            for c in contours:
                x, y, w, h = cv2.boundingRect(c)
            
# Make sure contour area is large enough
                #if (cv2.contourArea(c)) < 500 and (cv2.contourArea(c)) > 9:
                contour_img = img_rgb[(int((y+h/2)-25)):(int((y+h/2)+25)), (int((x+w/2)-25)):(int((x+w/2)+25))]
                #cv2.imwrite(os.path.join(unlabeled_img, "contour_img.png"), contour_img)
 
                #img = cv2.imread(os.path.join(unlabeled_img, "contour_img.png"))
                if contour_img.size > 0:
                    img = cv2.resize(contour_img, (50, 50))
                    img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
                    img = np.array(img)
                    img = np.expand_dims(img, axis=0)
                    pred_score = model.predict(img, batch_size=1)

            
                    if pred_score[(0,0)] > 0.8:
                        cv2.rectangle(image,((int((x+w/2)-20)),(int((y+h/2)-20))), ((int((x+w/2)+20)),(int((y+h/2)+20))), (255,0,0), 1)
                        datalist.append([filename,x,y,w,h, pred_score[(0,0)], pred_score[(0,1)]])
        cv2.imwrite(os.path.join(results_dir,filename), image)          

#    df = pd.DataFrame(datalist,columns = ['filename','x', 'y', 'w', 'h', 'dust', 'others']) 
        
except:
    traceback.print_exc()

在 results folder 里面的结果应该会是这样，感觉是用这个方法比我之前用 detecto 弄出来的结果好很多，而且很容易做 tuning 和控制。最重要的是，不需要动用到 colab，方便很多。

就这样，我用另外一个方式来建立 object detection model。

又这样渡过一个星期六。

Journey Toward Automation With Machine Learning & AI Technologies

noreply@blogger.com (I Talk - You Do) — Sat, 03 Apr 2021 14:58:00 +0000

这个周末我来研究一些比较 concept 的问题。乘周末的空挡，赶快把我收在脑海已久的 concept 给画出来，做个记录。

Industrial 4.0, machine learning, AI, big data, data science, advanced data analytic 都是当今热门的话题，很多人（尤其是老板阶级人士）都相信，或是都希望，能够通过人工智慧科技来解决未来的问题。是不是说，只要所有的 process 都让人工智慧机器人来处理，就万无一失，没有问题？真的是这样吗？

在人工智慧这一块打转了三年，时间不长，但撞得墙可不少。从跌跌撞撞中走过来，也吸取了不少的宝贵经验，其实人工智慧机器人，只能够有效的在一个 stable and predictable 的 process 情况下正常的操作。

所以，如果你也想为你的公司将来注入 AI 科技，我的建议是，在你做任何投资之前（AI 装置是个很大的投资 ok )，先去看看你当今的 process capability, stability 是否符合人工智慧科技的条件。如果是的话，那么先恭喜你。

万一你发现你当今 process capability, stability 还是一团糟，那该怎么办？

答案很简单，先把你 AI 的念头放一边，先解决你 process performance 的问题吧。需要动用到什么方法来提升 process performance 呢? 那就得看你当时 process 的情况了。一般都是 8D 或是 Lean Six Sigma 这个策略。

先把你的 process 搞好，彻底了解 process parameter 和 output 的相关性。还有理清在整个作业流程里的 non value added process。把这些基本的事情搞好后，再来谈 AI 。

如果连一个 domain expert 都无法解释 process parameter 和 output 的相关性，那么你就甭想教会一个机器人来帮你解决问题。

Remark : 人工智慧发展会为 Lean Six Sigma 专才带来更多的工作机会。

Text or Character Detection With Open CV

noreply@blogger.com (I Talk - You Do) — Wed, 31 Mar 2021 09:45:00 +0000

几天前同事发来了张产品照片过来，问我是j有办法用 computer vision 技术来自动化 text marking 位置检测。根据他的解说，今天的检测是通过 production operator 以目检的方式来执行，效果不是很好，基本上就是慢，误判也多。所以他希望能够借用 AI 来取代这个目检的工作。

今天我就来记录一下因为这个单子而学到的新知识。当然，我不会公开我实际 solution 是如何使用（商业机密）。我只能够借用以下图片来解释如何使用 Open CV 来从一个图片中找出每一个字体的 coordinate。有了这些 coordiante 的数据，接下来的要做的就是加减乘除来找出所要的答案。

OK，今天要分享的 code，就是要找出以下图片里每个字体的 coordiante，然后把所有的数据列再一个表上。

ok，废话少说，直接进入主题，coding

1. 先把需要的 package 给 load 出来

# load required library
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
import os
import cv2
import pandas as pd

2. set working directory

# set working directory
base_dir_path = "."
image_dir = os.path.join(base_dir_path,'img_dir')

3. load image 出来，顺便转换成 gray scale

# read all image from image directory
img_rgb = cv2.imread(os.path.join("sample_img_1.jpg"),0)
plt.imshow(img_rgb,cmap='gray')

4. 一般做这类型的 object detection，我们需要把图片弄蒙一些，主要是把字体(feature) 弄得粗一些，好让这些 feature 在转换成 contour 的时候会比较明显。然后再把图片转换成 binary 格式。 cv2.blur(img_rgb, (2, 2)) 这条 code 里面的 (2，2）其实蒙度 (in x & y direction)，数目越大，图片就越蒙。要用什么数字才对？看情况。。。

第二条 code 基本上就是把图片转换成 binary format，就这么简单。

可以把 binarized 的图片 print 出来看，字体是不是便粗了 ? 如果还不够好，那么可以从新调整一下 blur 的参数，看看是否能够改善。

# image preprocessing for charactor detection

img_blur = cv2.blur(img_rgb, (2, 2)) 

ret, img_thr = cv2.threshold(img_blur, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)

plt.figure(figsize = (14,8))
plt.imshow(img_thr, cmap='gray')

5. 用 open cv 的 contour detection 功能来把每个字体的 contour 给找出来

# use contours to detect the character
contours, hierarchy = cv2.findContours(img_thr,
  cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[-2:]

print('Total number of contours detected: ' + str(len(contours)))

6. 现在可以用 contour detection 找到的数据，把每个字体框出来。同时列出每个字体的 coordinate。

# Draw a bounding box around all contours
# store all bounding box data into a data frame name df
datalist = []
image = img_rgb
for c in contours:
      x, y, w, h = cv2.boundingRect(c)
 
    # Make sure contour area is large enough
      if (cv2.contourArea(c)) < 500 and (cv2.contourArea(c)) > 1:
        cv2.rectangle(image,(x,y), (x+w,y+h), (0,0,255), 1)

        datalist.append([x,y,w,h])
        
df = pd.DataFrame(datalist,columns = ['x', 'y', 'w', 'h'])
df = df.sort_values(by = 'y')
df = df.reset_index(drop=True)

一下就是我想要的结果，其实 detection 还蛮准的。

7. OK，最后一个步骤，把 image 和 dataframe expert 出去。

cv2.imwrite(os.path.join("sample_img_result.png"), image)
df.to_csv('txt_coordinate.csv',index = True, sep = ',')

今天到此为止。

How To Train An Object Detection Model with Detecto

noreply@blogger.com (I Talk - You Do) — Mon, 08 Mar 2021 16:31:00 +0000

偷懒了一个多月，是时候让这个 blog 重新活动活动了。一个多月，我到底忙了什么？说实在的，我自己也不知道。不过，我的确做了两个多礼拜的夜猫子，就是为了从新 optimize 一个之前用 detecto train 出来的 object detection model。

想知道 detecto 到底是什么东东，可以参考这大师的 blog 。

今天要在这里记录我如何使用 detecto 来 train 出一个能够帮数星星的 object detection model。

以下 sample 就是我忙了几个礼拜的通宵所得到的结果。

要做这样的 object detection model，除了 detector，还需要动用到 image annotation tool 和 google colab。

我是用 labelimg 这个工具来做我的 image annotation，为什么选 labelimg 呢？理由很简单，因为我学会用一个工具之后，就懒得去学另外一个工具了。

当然，事先必须要安装好 labelimg 这个工具。怎么安装呢？可以参考这个 link 。能否顺利安装，真的需要一点运气。记得去年安装这个 package 的时候，真的碰了不少的挑战，花了几个小时的 google，结果是怎样被我搞定，说真的我自己也不知道。

这里我不谈 labelimg 的用法，改天 “有空” 再补上。

好，废话少说，直接进入主题。做这类型的 image classifier，training testing data set 的准备工作就是要做 image annotation。用 labelimg 这个工具，把图片里的 targeted object 给框出来，然后把资料 save 成 xml format。就是这样。一张图可以有超过一个同样或是不一样的 object。

在这个 case，我主要的目的是要数星星，不管是什么星星，大的也好，小的也好，我都把它归类于一种 category，所以这里我只有 d1一个 class。如果想要用 detecto train 一个可以同时做 classification 的 object detection model，那么我们可以 annotate 超过一个 classification。

开始的时候我是有尝试弄三个 classification，结果。。。。我放弃了，所以才会有只有一个 class 的 object detection model。

以下是一些已经 annotate 的样本（当然，两三张 image 是不够的，至少也要准备五十张以上才可以看到一些效果）。就是这样，每一张 image file 跟一个同样名字的 xml file。必须注意的是，当 xml file 弄好了之后，就不要再去 rename 图片的名字。要不然，再 model training 的时候会出现 error。

training data set 弄好了之后，就下来就是把 training data set upload 上 google drive。一般我会设定这样的 file structure 方便我做 coding。我会把 training data set 收在 train folder 里。testing data set 就收在 valid 的 folder。

由于这 detecto 背后是使用了 fast rcnn 的架构，是一个相当大的 CNN，一般的电脑是无法处理这样大的 CNN 的，除非你有自己的 GPU，另一个免费的方法就是 google colab 了。

Google colab 提供大家一天12个小时的免费 GPU resource。但是，有个问题就是，如果我们的 web browser idle 超过 45 分钟，那么你或许会被 google 踢出局，结果全功尽弃，所以再 model training 操作的时刻，最好是每半个小时用 mouse click 一下web broswer。

OK，该准备的都准备好了，是做 coding 的时候了。这些 code 我是直接写在 colab 里面的，要怎么用 colab ？很简单，问 google 就行。

1. 基本的 Python 设定，和把需要用的 library load 出来。

link colab 去 google drive，和 set up training testing image directory

安装 detecto。这里我指定安装 detecto version 1.1.6。如果没有这样的指示，colab 就会把最新

版本的 detecto 给安装近来。之前试过 1.1.6 之后的版本，很多问题。所以才会有这样的设

定。

一点需要注意的是，在跑以下 code 之前，记得在 colab 的 Edit >> Notebook Setting >> 选择 GPU，然后 save。要不然的话，hmmm..... 真的是要等上一个天长地久才能够把一个 model 弄出来。

# set up the training and testing image directory
# here google will give you a password, you need to copy the password and 
# paste it to a field. Read and follow the instruction
import os
import cv2
from google.colab import drive

drive.mount('/content/drive')
os.chdir('/content/drive/My Drive/detecto_tutorial')

# tested detector version 1.2.0 this version generate large error
!pip install detecto==1.1.6
#!pip install detecto

2. image augmentation，简单来说，就是用这个方法来加大 training data set 的数量

# image augmentations model
# it should be place before the model training
from detecto import core, utils, visualize
from torchvision import transforms

augmentations = transforms. Compose([
      transforms.ToPILImage(),
      transforms.RandomHorizontalFlip(0.5),
      #transforms.ColorJitter(saturation = 0.5),
      transforms.ToTensor(),
      utils.normalize_transform(),                               
      ])

dataset = core.Dataset('dust_count_train/', transform = augmentations)

loader = core.DataLoader(dataset, batch_size = 5, shuffle = True)

3. Ok，可以开始做 model training 了，这里我引用了detecto 的 auto train code，直接 run 就可

以，没有 parameter 可以玩。Anyway，train 出来的 model 还可以。这个步骤一般需要一两个小时才可以完成，所以需要一些耐心，同时也需要确保你的 web browser 没有 idle 太久而被 google 踢出场。

# this is the auto train the model
from detecto import core, utils, visualize

dataset = core.Dataset('dust_count_train/',  transform = augmentations)
model = core.Model(['d1'])

model.fit(dataset)

4. 之后就可以把 train 好的 model save 起来。.pth 是一个 pythoch 的 format

# save the model 
# Rev2 include image from PoB
model.save('dust_count_Rev8.pth')

5. OK，可以做 validation 了。先把 model load 出来

# load the model 
#loader = core.DataLoader(dataset, batch_size = 2, shuffle = True)
model = core.Model.load('dust_count_Rev1.pth', ['d1'])

6. 随便从 validation 的 folder 挑一张图片来做测试，看看效果如何

# Specify the path to your image
image = utils.read_image('dust_cout_valid/3img.jpg')

predictions = model.predict(image)

labels, boxes, scores = predictions
print(labels) 
print(boxes)
print(scores)

# visualize the test result
from detecto import core, utils, visualize
visualize.show_labeled_image(image, boxes, labels)

以下就是得到的结果。虽然有了结果，但是想要知道图片里到底有多少颗星星，每颗星星的 coordinate，这样的结果其实帮助不大，没关系，接下来我可以把所有星星的数据都列出来，这样会更好。

8. OK，以下的步骤就是把 object detection 的数据弄出来，然后在原来的图片上把找到的星星标出来，save 成一张 .jpg file。

import pandas as pd

# convert array to dataframe
boxes_coordinate = pd.DataFrame(boxes)
labels = pd.DataFrame(labels)
scores = pd.DataFrame(scores)

print(boxes_coordinate, scores)

# rearrange the dataframe and save box coordinate in a csv file
boxes_coordinate_2 = pd.concat([labels, boxes_coordinate, scores ], axis = 1, sort = False)
boxes_coordinate_2.to_csv('boxes_coordinate_2.csv', header=True, index=False)
boxes_coordinate_2

# rename the header
df = boxes_coordinate_2
df.columns=['id', 'x', 'y', 'x_width', 'y_height', 'pred']
df.to_csv('boxes_coordinate_2.csv', header=True, index=False)

df

img_temp = image

# draw the box into the original image
import cv2
for i in range (len(df)):
  if df.loc[i, 'pred'] > 0.05:
    x = df.loc[i,'x']
    y = df.loc[i,'y']
    x1 = df.loc[i,'x_width']
    y1 = df.loc[i,'y_height']
    
    x = int(float(x))
    y = int(float(y))
    x1 = int(float(x1))
    y1 = int(float(y1))
    
    x_width = x1 - x
    y_height = y1 - y

    top_left = (x,y)
    bottom_right = (x + x_width, y + y_height)
    cv2.rectangle(img_temp, top_left, bottom_right, 255, 2)

# save the image in png format
import matplotlib.pyplot as plt

from matplotlib import pyplot as plt

plt.figure(figsize = (40,4))
plt.imshow(img_temp, interpolation='nearest')
plt.imsave('img_temp.png', img_temp)
#plt.figure(figsize = (14,8))

Ok, object detection model training 就这样完成。

下一次 “有空”，我会示范如何用 manual 的方法来 train 一个 object detection model。

好了，今天到此为止，12:30 am，今天又做了夜猫子。

XGBoost Classification Model - R

noreply@blogger.com (I Talk - You Do) — Sun, 24 Jan 2021 15:15:00 +0000

昨天用 XGBoost 做了 Regression analysis, 今天继续来完成 Classification 的那一部分

这一次，用的是 Logistic Regression - R 的数据。我们来看看 XGBoost 是否比 Logistic Regression, Decision Tree 和 Random Forest 厉害。或是容易使用。

如果你觉得我的 post 对你有帮助，希望你能够帮忙 click click 一下我部落格里面的广告鼓励鼓励

1. 基本的 R 设定，和把需要用的 library load 出来。

setwd("C:/Users/mokf/Desktop/Temp")
pacman::p_load(corrplot, broom, ggpubr, ggplot2,tidyverse, forecast, caret, 
               MASS, relaimpo, car, GGally, ggbiplot, xgboost)

raw_data = read.csv('Framingham_Heart_study_dataset.csv', header = TRUE)

head(raw_data)

> head(raw_data)
  ID male age education currentSmoker cigsPerDay BPMeds prevalentStroke prevalentHyp
1  1    1  39         4             0          0      0               0            0
2  2    0  46         2             0          0      0               0            0
3  3    1  48         1             1         20      0               0            0
4  4    0  61         3             1         30      0               0            1
5  5    0  46         3             1         23      0               0            0
6  6    0  43         2             0          0      0               0            1
  diabetes totChol sysBP diaBP   BMI heartRate glucose TenYearCHD
1        0     195 106.0    70 26.97        80      77          0
2        0     250 121.0    81 28.73        95      76          0
3        0     245 127.5    80 25.34        75      70          0
4        0     225 150.0    95 28.58        65     103          1
5        0     285 130.0    84 23.10        85      85          0
6        0     228 180.0   110 30.30        77      99          0

2. 做个数据处理，把 education 删除，也顺便看看有没有 na value

anyNA(raw_data)
sum(apply(raw_data, 1, anyNA))
colSums(is.na(raw_data))

df = na.omit(raw_data)
df$education = NULL

3. 准备 training 和 testing dataset，今天用的方法和 python 的方式相似。

set.seed(123)    
intrain = createDataPartition(y = df$TenYearCHD, p = 0.7, list = FALSE)
training = df[intrain,]
testing = df[-intrain,] 

x_train = training 
x_train$TenYearCHD = NULL
y_train = training$TenYearCHD

x_test = testing
x_test$TenYearCHD = NULL

4. 设定 XGBoost model。这里有几个 parameter 可以玩。由于这组数据是 Classification 的数据，所以需要把 gbtree 功能打开。

xgb = xgboost(data = data.matrix(x_train), 
              label = y_train, 
              nrounds = 30,
              eta = 0.8, 
              max_dept = 15,
              subsample = 0.5,
              colsample_bytree = 0.5, 
              objective = 'multi:softprob', 
              num_class = 2, 
              nthread = 3,
              booster = 'gbtree',
              #booster = 'gblinear',
              set.seed(123)
              
              )

5. model training 出来的 report 就像这样，default setting 是用 rmse 来量，如果不喜欢的话也可以换，要怎么换呢？就得去 help 那里参考了。

[22:37:26] WARNING: amalgamation/../src/learner.cc:516: 
Parameters: { max_dept } might not be used.

  This may not be accurate due to some parameters are only used in language bindings but
  passed down to XGBoost core.  Or some parameters are not used but slip through this
  verification. Please open an issue if you find above cases.


[1]	train-merror:0.135494 
[2]	train-merror:0.126513 
[3]	train-merror:0.125732 
[4]	train-merror:0.122218 
[5]	train-merror:0.117532 
[6]	train-merror:0.114799 
[7]	train-merror:0.097228 
[8]	train-merror:0.101132 
[9]	train-merror:0.087075 
[10]	train-merror:0.079266 
[11]	train-merror:0.076142 
[12]	train-merror:0.075752 
[13]	train-merror:0.069504 
[14]	train-merror:0.065599 
[15]	train-merror:0.056619 
[16]	train-merror:0.048028 
[17]	train-merror:0.045685 
[18]	train-merror:0.041390 
[19]	train-merror:0.037876 
[20]	train-merror:0.035143 
[21]	train-merror:0.033581 
[22]	train-merror:0.029285 
[23]	train-merror:0.024209

6. 用 testing dataset 来做一个 validation

由于 predicted 出来的是一个 probability value，麻烦的是所有的 classification probability value 都在同一个 column 里面，所以这里需要做一些处理，我只把 class 0 的 probability 挑出来。同时设定一个 threshhold value = 0.5。接下来才来慢慢玩

Confusion Matrix 的结果显示，基本上和 decision tree 还有 random forest 的结果相似。其实我还以为 XGBoost 可以解决之前的问题。

y_pred = predict(xgb, data.matrix(x_test))
y_pred = as.data.frame(y_pred)

test = as.data.frame(y_pred[ c(TRUE,FALSE), ])    # rows

y_pred_class = ifelse(test$`y_pred[c(TRUE, FALSE), ]` > 0.5, 0, 1)
y_pred_class = as.factor(y_pred_class)
y_pred_class = as.data.frame(y_pred_class)
y_pred_class$y_test = testing$TenYearCHD
y_pred_class$y_test = as.factor(y_pred_class$y_test)


prediction = y_pred_class$y_pred_class
reference = y_pred_class$y_test
confusionMatrix(prediction, reference)

Confusion Matrix and Statistics

          Reference
Prediction   0   1
         0 871 148
         1  54  24
                                          
               Accuracy : 0.8159          
                 95% CI : (0.7916, 0.8384)
    No Information Rate : 0.8432          
    P-Value [Acc > NIR] : 0.9935          
                                          
                  Kappa : 0.1044          
                                          
 Mcnemar's Test P-Value : 6.011e-11       
                                          
            Sensitivity : 0.9416          
            Specificity : 0.1395          
         Pos Pred Value : 0.8548          
         Neg Pred Value : 0.3077          
             Prevalence : 0.8432          
         Detection Rate : 0.7940          
   Detection Prevalence : 0.9289          
      Balanced Accuracy : 0.5406          
                                          
       'Positive' Class : 0

8. 换个 threshold value 来看看能否改善 specificity 的问题

OK, specificity 是有一些改善。但是还不太理想。

y_pred = predict(xgb, data.matrix(x_test))
y_pred = as.data.frame(y_pred)

test = as.data.frame(y_pred[ c(TRUE,FALSE), ])    # rows

y_pred_class = ifelse(test$`y_pred[c(TRUE, FALSE), ]` > 0.9, 0, 1)
y_pred_class = as.factor(y_pred_class)
y_pred_class = as.data.frame(y_pred_class)
y_pred_class$y_test = testing$TenYearCHD
y_pred_class$y_test = as.factor(y_pred_class$y_test)

Confusion Matrix and Statistics

          Reference
Prediction   0   1
         0 601  83
         1 324  89
                                          
               Accuracy : 0.629           
                 95% CI : (0.5996, 0.6577)
    No Information Rate : 0.8432          
    P-Value [Acc > NIR] : 1               
                                          
                  Kappa : 0.1065          
                                          
 Mcnemar's Test P-Value : <2e-16          
                                          
            Sensitivity : 0.6497          
            Specificity : 0.5174          
         Pos Pred Value : 0.8787          
         Neg Pred Value : 0.2155          
             Prevalence : 0.8432          
         Detection Rate : 0.5479          
   Detection Prevalence : 0.6235          
      Balanced Accuracy : 0.5836          
                                          
       'Positive' Class : 0

OK，今天总算有点成绩。下一个 post 要来看看 XGBoost 怎样来处理我之前那个有 bias 的心脏病的 dataset。

如果你觉得我的 post 对你有帮助，希望你能够帮忙 click click 一下我部落格里面的广告鼓励鼓励

8. 换个 threshold value 来看看能否改善 specificity 的问题

OK, specificity 是有一些改善。但是还不太理想。

y_pred = predict(xgb, data.matrix(x_test))
y_pred = as.data.frame(y_pred)

test = as.data.frame(y_pred[ c(TRUE,FALSE), ])    # rows

y_pred_class = ifelse(test$`y_pred[c(TRUE, FALSE), ]` > 0.9, 0, 1)
y_pred_class = as.factor(y_pred_class)
y_pred_class = as.data.frame(y_pred_class)
y_pred_class$y_test = testing$TenYearCHD
y_pred_class$y_test = as.factor(y_pred_class$y_test)

Confusion Matrix and Statistics

          Reference
Prediction   0   1
         0 601  83
         1 324  89
                                          
               Accuracy : 0.629           
                 95% CI : (0.5996, 0.6577)
    No Information Rate : 0.8432          
    P-Value [Acc > NIR] : 1               
                                          
                  Kappa : 0.1065          
                                          
 Mcnemar's Test P-Value : <2e-16          
                                          
            Sensitivity : 0.6497          
            Specificity : 0.5174          
         Pos Pred Value : 0.8787          
         Neg Pred Value : 0.2155          
             Prevalence : 0.8432          
         Detection Rate : 0.5479          
   Detection Prevalence : 0.6235          
      Balanced Accuracy : 0.5836          
                                          
       'Positive' Class : 0

8. 换个 threshold value 来看看能否改善 specificity 的问题

OK, specificity 是有一些改善。但是还不太理想。

y_pred = predict(xgb, data.matrix(x_test))
y_pred = as.data.frame(y_pred)

test = as.data.frame(y_pred[ c(TRUE,FALSE), ])    # rows

y_pred_class = ifelse(test$`y_pred[c(TRUE, FALSE), ]` > 0.9, 0, 1)
y_pred_class = as.factor(y_pred_class)
y_pred_class = as.data.frame(y_pred_class)
y_pred_class$y_test = testing$TenYearCHD
y_pred_class$y_test = as.factor(y_pred_class$y_test)

Confusion Matrix and Statistics

          Reference
Prediction   0   1
         0 601  83
         1 324  89
                                          
               Accuracy : 0.629           
                 95% CI : (0.5996, 0.6577)
    No Information Rate : 0.8432          
    P-Value [Acc > NIR] : 1               
                                          
                  Kappa : 0.1065          
                                          
 Mcnemar's Test P-Value : <2e-16          
                                          
            Sensitivity : 0.6497          
            Specificity : 0.5174          
         Pos Pred Value : 0.8787          
         Neg Pred Value : 0.2155          
             Prevalence : 0.8432          
         Detection Rate : 0.5479          
   Detection Prevalence : 0.6235          
      Balanced Accuracy : 0.5836          
                                          
       'Positive' Class : 0

8. 可以 plot 个 bar chart 出来看看每个 factor 的重要性

model <- xgb.dump(xgb, with_stats = T)
model[1:14] #This statement prints top 10 nodes of the model

names <- dimnames(data.matrix(x_train))[[2]]

# Compute feature importance matrix
importance_matrix <- xgb.importance(names, model = xgb)
# Nice graph
xgb.plot.importance(importance_matrix[1:15,])

Ok, 总算是弄好一个 working 的 script 了。不过这 script 看起来怪怪的，总觉得那里有点做错。

有些地方还需要一些 trouble shooting，比方说 xgboost 里面的 objective 那个 parameter，我该去 binary:logistic 它就出 error 了，这个问题等我有机会看回，再来做 trouble shoot。今天迟了，再弄下去恐怕三点都没得睡。

XGBoost Linear Model - R

noreply@blogger.com (I Talk - You Do) — Sat, 23 Jan 2021 08:49:00 +0000

这个周末我来学 XGBoost （Extreme Gradient Boosting)。也是 Supervised machine learning 的一种。之前有同事提起这个 algorithm，传说中是很厉害的。

今天抽空看看这个大师的贴，看起来真的很厉害。

这个 algorithm 可以做 Regression 和 Classification，重点是比 Random Forest 快十倍以上，而且还有特别的 parameter 可以控制 overfitting 的问题，也可以 handle na value。

好，今天我就用之前 Multiple Linear Regression 的 dataset 来跑一个 demo，至于 classification 的 demo，我就留在下一个 post。

如果你觉得我的 post 对你有帮助，希望你能够帮忙 click click 一下我部落格里面的广告鼓励鼓励

1. 基本的 R 设定，和把需要用的 library load 出来。

setwd("C:/Users/mokf/Desktop/Temp")
pacman::p_load(corrplot, broom, ggpubr, ggplot2,tidyverse, forecast, caret, 
               MASS, relaimpo, car, GGally, ggbiplot, xgboost)

raw_data = read.csv('Admission_Predict_Ver1.1.csv', header = TRUE)

head(raw_data)

> head(raw_data)
  Serial.No. GRE.Score TOEFL.Score University.Rating SOP LOR CGPA Research
1          1       337         118                 4 4.5 4.5 9.65        1
2          2       324         107                 4 4.0 4.5 8.87        1
3          3       316         104                 3 3.0 3.5 8.00        1
4          4       322         110                 3 3.5 2.5 8.67        1
5          5       314         103                 2 2.0 3.0 8.21        0
6          6       330         115                 5 4.5 3.0 9.34        1
  Chance.of.Admit
1            0.92
2            0.76
3            0.72
4            0.80
5            0.65
6            0.90

2. 做个数据处理，把 Serial.No 删除，再把 Research 转为 factor。也顺便看看有没有 na value

raw_data$Serial.No. = NULL
raw_data$Research = as.factor(raw_data$Research)
anyNA(raw_data)
df = na.omit(raw_data)
df  = raw_data

3. 准备 training 和 testing dataset，今天用的方法和 python 的方式相似。

set.seed(123)    
intrain = createDataPartition(y = df$Chance.of.Admit, p = 0.7, list = FALSE)
training = df[intrain,]
testing = df[-intrain,] 

x_train = training 
x_train$Chance.of.Admit = NULL
y_train = training$Chance.of.Admit

x_test = testing
x_test$Chance.of.Admit = NULL

4. 设定 XGBoost model。这里有几个 parameter 可以玩。由于这组数据是 Linear Regression 的数据，所以我需要把 gbtree 的功能关掉 xgboost default setting 是 booster = ‘gbtree'。anyway，入股我不指定要用什么 booster，xgbooster 就会直接用 gbtree，还是有答案出来的。但是 gblinear 和 gbtree 的 parameter 设定有些不同，所以还是分开来比较好。

nrounds 就好像 epoch 那样，eta 就好像 learning rate。其他的都可以先锁定在 default value。

xgb = xgboost(data = data.matrix(x_train), 
              label = y_train, 
              nrounds = 200,
              eta = 0.3, 
              #booster = 'gbtree',
              booster = 'gblinear',
              lambda = 1,
              alpha = 0,
              lambda_bias = 0, 
              set.seed(123)
              
              )

5. model training 出来的 report 就像这样，default setting 是用 rmse 来量，如果不喜欢的话也可以换，要怎么换呢？就得去 help 那里参考了。

[16:01:50] WARNING: amalgamation/../src/learner.cc:516: 
Parameters: { lambda_bias } might not be used.

  This may not be accurate due to some parameters are only used in language bindings but
  passed down to XGBoost core.  Or some parameters are not used but slip through this
  verification. Please open an issue if you find above cases.


[1]	train-rmse:0.124964 
[2]	train-rmse:0.122675 
[3]	train-rmse:0.121094 
[4]	train-rmse:0.119648 
[5]	train-rmse:0.118252 
[6]	train-rmse:0.116952 
[7]	train-rmse:0.115716 
[8]	train-rmse:0.114568 
[9]	train-rmse:0.113517 
[10]	train-rmse:0.112497 
[11]	train-rmse:0.111662 
[12]	train-rmse:0.110821 
[13]	train-rmse:0.109986 
[14]	train-rmse:0.109208 
[15]	train-rmse:0.108486 
[16]	train-rmse:0.107740 
[17]	train-rmse:0.107102 
[18]	train-rmse:0.106515 
[19]	train-rmse:0.105911 
[20]	train-rmse:0.105372 
[21]	train-rmse:0.104824 
[22]	train-rmse:0.104342 
[23]	train-rmse:0.103842 
[24]	train-rmse:0.103410 
[25]	train-rmse:0.103004 
[26]	train-rmse:0.102578

6. 用 testing dataset 来做一个 validation

可以尝试改变一下 model training 得 parameter，包括把 booster 转成 booster = ’gbtree‘。看看有什么反应。这里我就不 demo 了。

y_pred = predict(xgb, data.matrix(x_test))
y_test = testing$Chance.of.Admit
scatterplot(y_test, y_pred)

7. 可以弄个 residual plot 来看看，和 multiple linear regression model 比较，那个比较好？

y_test_res = y_test - y_pred

model_stats = as.data.frame(y_test_res)

binwidth = (max(model_stats) - min(model_stats))/15

Histogram <- ggplot(data = model_stats, aes(y_test_res)) +
              geom_histogram(colour="darkgray", fill="blue", binwidth = binwidth) + 
              labs(x="Residual", y="Count", title="Histogram")

Observation_Order = as.integer(row.names(model_stats))

Residual_vs_Order = ggplot(model_stats, aes(x=Observation_Order, y=y_test_res)) +   
  geom_line(color="blue") +  geom_point(color="blue", size=2) + 
  geom_hline(yintercept = 0,color="red")+ 
  labs(x="Observation Order", y="Residual", title="Residual_vs_Order")

Residual_vs_Fitted = ggplot(model_stats, aes(x=y_pred, y=y_test_res)) +   
  geom_point(color="blue", size=2) +
  geom_hline(yintercept = 0,color="red")+                     
  labs(x="Fitted", y="Residual", title="Residual vs Fitted")


QQ_Normal = ggplot(model_stats, aes(sample = y_test_res)) + 
  stat_qq() + stat_qq_line() +
  labs(x="Theoretical", y="Sample", title="QQ Nornal")

ggarrange(Histogram, Residual_vs_Fitted, Residual_vs_Order, QQ_Normal )

8. 也可以把 important feature 弄出来看，看看那个 feature 对整个 model 的 contribution

important_matrix = xgb.importance(xgb$feature_names, model = xgb)

# this code is to avoid R perform auto sort of x-axis
important_matrix$Feature = factor(important_matrix$Feature, levels = important_matrix$Feature)

ggplot(data=important_matrix, aes(x=important_matrix$Feature, y=important_matrix$Weight)) +
  geom_bar(stat="identity", fill = 'blue')

OK，今天总算有点成绩。下一个 post 要来看看 XGBoost 怎样来处理我之前那个有 bias 的心脏病的 dataset。

如果你觉得我的 post 对你有帮助，希望你能够帮忙 click click 一下我部落格里面的广告鼓励鼓励

Displaying Multiple Image In One Page With Python

noreply@blogger.com (I Talk - You Do) — Wed, 20 Jan 2021 05:24:00 +0000

今天来学习如何用 python code 来从新排列 crop 出来的图片。经过两个小时的 Google，终于找到一个至少让我看得懂的贴来做参考。OK 就来看看我一半抄来，一半自己弄出来的 code

1. 把需要用到的 Library load 出来。

# import required library
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
import os
import cv2

2. 设定 working directory

# set working directory
base_dir_path = "."
image_dir = os.path.join(base_dir_path,'img_dir')

3. 把 image directory 里面的 file name list 出来

# list the image file from the image directory
files = os.listdir(image_dir)
files

['0_100.jpg',
 '10_100.jpg',
 '11_100.jpg',
 '12_100.jpg',
 '13_100.jpg',
 '14_100.jpg',
 '15_100.jpg',
 '16_100.jpg',
 '17_100.jpg',
 '18_100.jpg',
 '19_100.jpg',
 '1_100.jpg',
 '20_100.jpg',
 '21_100.jpg',
 '22_100.jpg',
 '23_100.jpg',
 '24_100.jpg',
 '25_100.jpg',
 '26_100.jpg',
 '2_100.jpg']

4. 把图片 load 上来。把所有的 image array stack 进一个大 array

如果你觉得我的 post 对你有帮助，希望你能够帮忙 click click 一下我部落格里面的广告鼓励鼓励

im_qty = len(files)
fs = []
for i in range (0,im_qty):
    filename = os.path.join(image_dir,files[i])
    im = Image.open(filename)
    im = im.resize((50, 50), Image.ANTIALIAS)

    fs.append(im)

5. 把图片的 image size 找出来

# get the image size 
x,y = fs[0].size

6. 根据我们想设定的 column 和 row，弄一张大张的图片 template。这里我做了一个小小的 automation，我只需要在 ncol 设定我要把图片排列为多少个 column，system 就会自己计算需要多少的 row 来把所有的图片 fit 进去。

ncol = 5
nrow = int(round(im_qty/ncol, 0))
cvs = Image.new( 'RGB',size = (x*ncol, y*nrow))

7. 一下的 code 会把图片直线排列

for i in range(len(fs)):
    px, py = x*int(i/nrow), y*(i%nrow)
    cvs.paste(fs[i],(px,py))

cvs.save('arranged_img_1.png',format='png')
cvs

8. 一下的 code 会把图片横线排列

for i in range(len(fs)):
    px,py = x*(i%ncol), y*int(i/ncol)
    cvs.paste(fs[i], (px,py))

cvs.save('arranged_img_2.png',format='png')
cvs

OK，完成。

如果你觉得我的 post 对你有帮助，希望你能够帮忙 click click 一下我部落格里面的广告鼓励鼓励

Date	Location	MinTemp	MaxTemp	Rainfall	Evaporation	Sunshine	WindGustDir	WindGustSpeed	WindDir9am	WindDir3pm	WindSpeed9am	WindSpeed3pm	Humidity9am	Humidity3pm	Pressure9am	Pressure3pm	Cloud9am	Cloud3pm	Temp9am	Temp3pm	RainToday	RainTomorrow	Location2
0	2008-12-01	Albury	13.4	22.9	0.6	5.469824	7.624853	W	44.0	W	WNW	20.0	24.0	71.0	22.0	1007.7	1007.1	8.000000	4.503167	16.9	21.8	No	No	Albury
1	2008-12-02	Albury	7.4	25.1	0.0	5.469824	7.624853	WNW	44.0	NNW	WSW	4.0	22.0	44.0	25.0	1010.6	1007.8	4.437189	4.503167	17.2	24.3	No	No	Albury
2	2008-12-03	Albury	12.9	25.7	0.0	5.469824	7.624853	WSW	46.0	W	WSW	19.0	26.0	38.0	30.0	1007.6	1008.7	4.437189	2.000000	21.0	23.2	No	No	Albury
3	2008-12-04	Albury	9.2	28.0	0.0	5.469824	7.624853	NE	24.0	SE	E	11.0	9.0	45.0	16.0	1017.6	1012.8	4.437189	4.503167	18.1	26.5	No	No	Albury
4	2008-12-05	Albury	17.5	32.3	1.0	5.469824	7.624853	W	41.0	ENE	NW	7.0	20.0	82.0	33.0	1010.8	1006.0	7.000000	8.000000	17.8	29.7	No	No	Albury
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
145454	2017-06-20	Uluru	3.5	21.8	0.0	5.469824	7.624853	E	31.0	ESE	E	15.0	13.0	59.0	27.0	1024.7	1021.2	4.437189	4.503167	9.4	20.9	No	No	Uluru
145455	2017-06-21	Uluru	2.8	23.4	0.0	5.469824	7.624853	E	31.0	SE	ENE	13.0	11.0	51.0	24.0	1024.6	1020.3	4.437189	4.503167	10.1	22.4	No	No	Uluru
145456	2017-06-22	Uluru	3.6	25.3	0.0	5.469824	7.624853	NNW	22.0	SE	N	13.0	9.0	56.0	21.0	1023.5	1019.1	4.437189	4.503167	10.9	24.5	No	No	Uluru
145457	2017-06-23	Uluru	5.4	26.9	0.0	5.469824	7.624853	N	37.0	SE	WNW	9.0	9.0	53.0	24.0	1021.0	1016.8	4.437189	4.503167	12.5	26.1	No	No	Uluru
145458	2017-06-24	Uluru	7.8	27.0	0.0	5.469824	7.624853	SE	28.0	SSE	N	13.0	7.0	51.0	24.0	1019.4	1016.5	3.000000	2.000000	15.1	26.0	No	No	Uluru