전체 소스 코드

 

GitHub - 21june/FaceMaskDetection: C# WPF - Face Mask Detection

C# WPF - Face Mask Detection. Contribute to 21june/FaceMaskDetection development by creating an account on GitHub.

github.com

 

Nuget 패키지

 다음과 같이 Nuget 패키지를 등록합니다.

  <ItemGroup>
    <PackageReference Include="OpenCvSharp4" Version="4.10.0.20241108" />
    <PackageReference Include="OpenCvSharp4.Extensions" Version="4.10.0.20241108" />
    <PackageReference Include="OpenCvSharp4.runtime.win" Version="4.10.0.20241108" />
    <PackageReference Include="OpenCvSharp4.Windows" Version="4.10.0.20241108" />
    <PackageReference Include="OpenCvSharp4.WpfExtensions" Version="4.10.0.20241108" />
  </ItemGroup>

 

UI XAML 파일 (MainWindow.xaml)

 UI는 다음과 같은 소스 코드를 따릅니다.

<Window x:Class="MaskDetection.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:MaskDetection"
        mc:Ignorable="d"
        Title="MainWindow" Height="640" Width="1024">	
	<Grid>
		<Grid.ColumnDefinitions>
			<ColumnDefinition Width="0.6*" />
			<ColumnDefinition Width="0.4*" />
		</Grid.ColumnDefinitions>
        
		<!-- Left (Picture) --> 
		<Grid Grid.Column="0">
			<Image x:Name="image_cam" Stretch="Uniform"/>
		</Grid>
        
		<!-- Right (Menu) -->
		<Grid Grid.Column="1">
			<Grid.RowDefinitions>
				<!-- 1. Input-->
				<RowDefinition Height="0.3*" />
				<!-- 2. Model -->
				<RowDefinition Height="0.2*" />
				<!-- 3. Face Detection -->
				<RowDefinition Height="0.2*" />
				<RowDefinition Height="0.3*" />
			</Grid.RowDefinitions>

			
			<!-- 1. Input -->
			<GroupBox Grid.Row="0" Header="Input" Margin="5" FontSize="15">
				<Grid>
					<Grid.RowDefinitions>
						<!-- Camera -->
						<RowDefinition Height="0.5*" />
						<!-- Image -->
						<RowDefinition Height="1.0*" />
					</Grid.RowDefinitions>
					<!-- Camera -->
					<Grid Grid.Row="0">
						<Grid.ColumnDefinitions>
							<ColumnDefinition Width="0.3*" />
							<ColumnDefinition Width="0.7*" />
						</Grid.ColumnDefinitions>
						<TextBlock Grid.Column="0" Text="Camera" VerticalAlignment="Center" FontSize="20" />
						<Button Grid.Column="1" x:Name="button_cam" Content="Open" Click="ClickEvent" FontSize="20" Margin="10"/>
					</Grid>
                    
					<!-- Image -->
					<Grid Grid.Row="1">
						<Grid.RowDefinitions>
							<RowDefinition Height="0.5*" />
							<RowDefinition Height="0.5*" />
						</Grid.RowDefinitions>
						<!-- Load Button... -->
						<Grid Grid.Row="0">
							<Grid.ColumnDefinitions>
								<ColumnDefinition Width="0.3*" />
								<ColumnDefinition Width="0.7*" />
							</Grid.ColumnDefinitions>
							<TextBlock Grid.Column="0" Text="Image" VerticalAlignment="Center" FontSize="20"/>
							<Button x:Name="button_image" Grid.Column="1" Content="Load" Click="ClickEvent" FontSize="20" Margin="10"/>
						</Grid>
						<!-- Path Text... -->
						<TextBlock x:Name="text_image" Grid.Row="1" TextWrapping="Wrap" VerticalAlignment="Center" Text="No File" FontSize="15"/>
					</Grid>
				</Grid>
			</GroupBox>


			<!-- 2. Model -->
			<GroupBox Grid.Row="1" Header="Mask Detection" Margin="5" FontSize="15">
				<Grid>
					<Grid.RowDefinitions>
						<RowDefinition Height="0.5*" />
						<RowDefinition Height="0.5*" />
					</Grid.RowDefinitions>
					<!-- Load -->
					<Grid Grid.Row="0">
						<Grid.ColumnDefinitions>
							<ColumnDefinition Width="0.3*" />
							<ColumnDefinition Width="0.7*" />
						</Grid.ColumnDefinitions>
						<TextBlock Grid.Column="0" Text="File" VerticalAlignment="Center" FontSize="20" />
						<Button x:Name="button_model" Grid.Column="1" Content="Load" Click="ClickEvent" FontSize="15" Margin="5"/>
					</Grid>
					<!-- Path -->
					<TextBlock x:Name="text_model" Grid.Row="3" TextWrapping="Wrap" VerticalAlignment="Center" Text="No File" FontSize="15"/>
				</Grid>
			</GroupBox>


			<!-- 3. Face Detection -->
			<GroupBox Grid.Row="2" Header="Face Detection" Margin="5" FontSize="15">
				<Grid>
					<Grid.RowDefinitions>
						<RowDefinition Height="0.5*" />
						<RowDefinition Height="0.5*" />
					</Grid.RowDefinitions>
					<!-- Enable -->
					<Grid Grid.Row="0">
						<Grid.ColumnDefinitions>
							<ColumnDefinition Width="0.3*" />
							<ColumnDefinition Width="0.7*" />
						</Grid.ColumnDefinitions>
						<TextBlock Grid.Column="0" Text="Enable" VerticalAlignment="Center" FontSize="20" />
						<CheckBox Grid.Column="1" x:Name="check_facedet" Content="Auto Face-Cognition" VerticalAlignment="Center" Margin="10" Click="ClickEvent"/>
					</Grid>
					<!-- Confidence -->
					<Grid Grid.Row="1">
						<Grid.ColumnDefinitions>
							<ColumnDefinition Width="0.3*" />
							<ColumnDefinition Width="0.7*" />
						</Grid.ColumnDefinitions>
						<TextBlock Grid.Column="0" Text="Confidence" VerticalAlignment="Center" FontSize="20" />
						<Slider x:Name="slider_face_conf" Grid.Column="1" Minimum="0" Maximum="100" VerticalAlignment="Center" ValueChanged="SliderEvent" />

					</Grid>
				</Grid>
			</GroupBox>

		</Grid>

	</Grid>
	
</Window>

 

 

MainWindow.xaml.cs

 다음과 같이 변수들을 초기화했으며, OpenCvSharp.Dnn.CvDnn.ReadNetFromOnnx 함수를 통해 이전 포스팅에서 생성한 onnx 파일을 로드해줍니다. modelPath 값의 경우 onnx 파일 경로에 맞게 수정해주셔야 합니다.

public partial class MainWindow : Window
{
    VideoCapture m_capture;
    Thread t_cap;
    bool m_isRunning = false;
    bool b_facecog = true;

    OpenCvSharp.Dnn.Net net;
    OpenCvSharp.Size resz = new OpenCvSharp.Size(224, 224);

    // Mean & Standard Deviation
    bool b_meanstd = false;
    static float[] mean = new float[3] { 0.5703f, 0.4665f, 0.4177f };
    static float[] std = new float[3] { 0.2429f, 0.2231f, 0.2191f };

    float face_confidence = 0.5f;

    public MainWindow()
    {
        InitializeComponent();
        m_capture = new VideoCapture();

        // 모델 로드
        string mask_model = "resnet18_Mask_12K_None_EPOCH200_LR0.0001.onnx";
        net = OpenCvSharp.Dnn.CvDnn.ReadNetFromOnnx(mask_model);

        // UI 처리
        if (!net.Empty())	text_model.Text = "Model: " + mask_model;
        else				text_model.Text = "Model: " + "No Model";

        slider_face_conf.Value = (int)(face_confidence * 100);
        check_facedet.IsChecked = b_facecog = true;
    }

    ...
}

 

 ClickEvent 함수는 각 UI의 클릭 이벤트 시 호출되는 함수입니다.

1. button_cam의 경우 카메라를 연결하고 영상을 가져와 추론 후 결과를 출력하는 과정을 스레드 해제까지 수행합니다.

2. button_image은 파일 열기 다이얼로그를 실행하여 이미지 파일을 선택하고 해당 이미지를 불러와 추론 후 결과를 나타냅니다.

3. button_model은 파일 열기 다이얼로그를 실행하여 모델 파일(*.onnx)을 선택하고 해당 모델을 불러와 추론 시 사용합니다.

4. check_facedet은 체크하면 사람의 얼굴을 찾고 각 얼굴 별 마스크를 착용했는지 확인합니다. 체크 해제 시에는 전체 이미지를 검사합니다.

 SliderEvent 함수는 슬라이더의 값 변경 시 호출됩니다. 해당 값을 계산하여 confidence 값에 사용합니다. 

// 버튼 클릭 이벤트
private void ClickEvent(object sender, RoutedEventArgs e)
{
    if (sender.Equals(button_cam)) // 카메라 연결/해제 버튼
    {
        if (!m_isRunning)
        {
            if (t_cap != null && t_cap.IsAlive)
            {
                MessageBox.Show("Camera is closing... Wait..", "Error");
                return;
            }
            t_cap = new Thread(new ThreadStart(ThreadFunc));
            t_cap.IsBackground = true; // 프로그램 꺼질 때 쓰레드도 같이 꺼짐
            m_isRunning = true;
            t_cap.Start();
            button_cam.Content = "Close";
        }
        else
        {
            m_isRunning = false;
            image_cam.Source = null;
            button_cam.Content = "Open";
        }
    }

    else if (sender.Equals(button_image)) // 이미지 로드 버튼
    {

        OpenFileDialog openFileDialog = new OpenFileDialog();
        openFileDialog.Filter = "PNG files (*.png)|*.png|BMP files (*.bmp)|*.bmp|JPG files (*.jpg)|*.jpg|JPEG files (*.jpeg)|*.jpeg|All files (*.*)|*.*";
        if (openFileDialog.ShowDialog() == true)
        {
            Mat image = Cv2.ImRead(openFileDialog.FileName);
            if (!image.Empty()) text_image.Text = "Image: " + openFileDialog.SafeFileName;
            else text_image.Text = "Image: " + "No Model";
            Run(image);
        }
    }
    else if (sender.Equals(button_model)) // 모델 로드 버튼
    {

        OpenFileDialog openFileDialog = new OpenFileDialog();
        openFileDialog.Filter = "ONNX Weight files (*.onnx)|*.onnx|All files (*.*)|*.*"; // ONNX 파일만
        if (openFileDialog.ShowDialog() == true)
        {
            net = OpenCvSharp.Dnn.CvDnn.ReadNetFromOnnx(openFileDialog.FileName);
            if (!net.Empty())	text_model.Text = "Model: " + openFileDialog.SafeFileName;
            else				text_model.Text = "Model: " + "No Model";
        }
    }
    else if (sender.Equals(check_facedet)) // face detection 체크 박스
    {
        if (check_facedet.IsChecked == true)	b_facedet = true;
        else									b_facedet = false;
    }
}
// Slider 값 변경 이벤트
private void SliderEvent(object sender, RoutedPropertyChangedEventArgs<double> e)
{
    if (sender.Equals(slider_face_conf))
    {
        face_confidence = (float)slider_face_conf.Value / 100.0f;
    }
}

 

 ThreadFunc 함수입니다. 카메라를 Open 시킨 후 플래그 값(m_isRunning)이 바뀔 때까지 스레드 풀링(Pooling)합니다. 루프 안에서 카메라로부터 영상을 받아와 추론을 하고 결과를 출력합니다.

private void ThreadFunc() // 카메라를 연결하고 프레임을 읽고 추론까지 진행함
{
    m_capture.Open(0, VideoCaptureAPIs.DSHOW);

    Mat frame = new Mat();
    while (m_isRunning)
    {
        if (m_capture.IsOpened() == true)
        {
            m_capture.Read(frame);
            if (!frame.Empty())
                Run(frame);
            Thread.Sleep(10); // prevent for lag
        }
        else
        {
            m_isRunning = false;
            image_cam.Dispatcher.Invoke(() => { image_cam.Source = null; });
            button_cam.Dispatcher.Invoke(() => { button_cam.Content = "Open"; });
        }
    }
    if (m_capture.IsOpened())
        m_capture.Release();
}

 

 ImageROI 함수는 face detection을 수행하는지 안하는지 체크하고 해당하는 이미지를 리스트에 담아 리턴해주는 역할을 수행합니다.

private void ImageROI(Mat image,  out List<OpenCvSharp.Rect> faces)
{
    faces = new List<OpenCvSharp.Rect>();

    if (b_facedet == true)
    {
        FaceCrop(image, out faces);
    }
    else
    {
        OpenCvSharp.Rect rt = new OpenCvSharp.Rect(0, 0, image.Width, image.Height);
        faces.Add(rt);
    }

}

 

 

 ImageROI 내부에서 사용된 FaceCrop 함수입니다. Face Detection 기법들이 포함되어있습니다. 기본으로 얼굴 인식이 훈련된 SSD Model을 불러오게 합니다. HaarCascade 기법도 코드에 포함되어있지만 실사용하기에 매우 부족한 성능이라 코드 포함만 해뒀고 실제로 사용하진 않았습니다. 

// face detection for using ssd (or haarcascade)
private void FaceCrop(Mat image, out List<OpenCvSharp.Rect> list)
{
    list = new List<OpenCvSharp.Rect>();

    if (true) // SSD Model : Useful
    {
        OpenCvSharp.Dnn.Net facenet;
        // Download: https://github.com/spmallick/learnopencv/blob/master/FaceDetectionComparison/models/deploy.prototxt
        var prototext = "deploy.prototxt";
        // Download: https://github.com/spmallick/learnopencv/blob/master/FaceDetectionComparison/models/res10_300x300_ssd_iter_140000_fp16.caffemodel
        var modelPath = "res10_300x300_ssd_iter_140000_fp16.caffemodel";
        facenet = Net.ReadNetFromCaffe(prototext, modelPath);
        Mat inputBlob = CvDnn.BlobFromImage(
            image, 1, new OpenCvSharp.Size(300, 300), new OpenCvSharp.Scalar(104, 177, 123),
            false, false
        );
        facenet.SetInput(inputBlob, "data");
        string[] outputs = facenet.GetUnconnectedOutLayersNames();
        Mat outputBlobs = facenet.Forward("detection_out");
        Mat ch1Blobs = outputBlobs.Reshape(1, 1);

        int rows = outputBlobs.Size(2);
        int cols = outputBlobs.Size(3);
        long total = outputBlobs.Total();
        ch1Blobs.GetArray(out float[] data);
        if (data.Length == 1) return;

        for (int i = 0; i < rows; i++)
        {
            float confidence = data[i * cols + 2]; // Access confidence score

            // 설정된 confidence 값보다 클 경우만
            if (confidence > face_confidence)
            {
                int x1 = (int)(data[i * cols + 3] * image.Width);
                int y1 = (int)(data[i * cols + 4] * image.Height);
                int x2 = (int)(data[i * cols + 5] * image.Width);
                int y2 = (int)(data[i * cols + 6] * image.Height);

                OpenCvSharp.Rect rt = new OpenCvSharp.Rect(x1, y1, x2, y2);

                int centerX = (rt.Left + rt.Right) / 2;
                int centerY = (rt.Top + rt.Bottom) / 2;

                int width = x2 - x1;
                int height = y2 - y1;

                // 그냥 face recognition 하면, 얼굴이 너무 빡세게 잡혀서.. 가로세로 10% 정도씩 늘려줌.
                float face_scale_X = 0.1f;
                float face_scale_Y = 0.1f;
                if (x1 - (width * face_scale_X) < 0) x1 = 0;
                else x1 = x1 - (int)(width * face_scale_X);

                if (x2 + (width * face_scale_X) > image.Width) x2 = image.Width;
                else x2 = x2 + (int)(width * face_scale_X);

                if (y1 - (height * face_scale_Y) < 0) y1 = 0;
                else y1 = y1 - (int)(height * face_scale_Y);

                if (y2 + (height * face_scale_Y) > image.Height) y2 = image.Height;
                else y2 = y2 + (int)(height * face_scale_Y);

                OpenCvSharp.Rect item = new OpenCvSharp.Rect(x1, y1, x2 - x1, y2 - y1);
                list.Add(item);
            }
        }
    }

    if (false) // Cascade Classifier : Useless
    {
        // Download: https://github.com/mitre/biqt-face/tree/master/config/haarcascades
        string filenameFaceCascade = "haarcascade_frontalface_alt2.xml";
        CascadeClassifier faceCascade = new CascadeClassifier();
        if (!faceCascade.Load(filenameFaceCascade))
        {
            Console.WriteLine("error");
            return;
        }

        // detect 
        OpenCvSharp.Rect[] faces = faceCascade.DetectMultiScale(image);
        foreach (var item in faces)
        {
            list.Add(item);
            Cv2.Rectangle(image, item, Scalar.Red); // add rectangle to the image
            Console.WriteLine("faces : " + item);
        }
    }
}

 

 NormalizeImage는 이미지 정규화를 수행합니다. 기본적으로 255를 나눠서 0~1의 값으로 Normalize 시킨 다음에, Mean 값 만큼 빼주고 Std 값 만큼 나눠주는 식으로 수행합니다. 허나 이것도 구현만 해두었고 실제로 사용하진 않습니다. ImageNet의 mean std 값으로도 해봤고 제가 직접 구한 트레이닝 데이터셋의 mean std 값으로도 넣어봤지만 안한 상태가 결과로써 가장 유의미했기 때문입니다.

// 정규화 과정
private void NormalizeImage(ref Mat img)
{
    img.ConvertTo(img, MatType.CV_32FC3);
    Mat[] rgb = img.Split();

    // 0.0f~1.0f
    rgb[0] = rgb[0].Divide(255.0f); // B
    rgb[1] = rgb[1].Divide(255.0f); // G
    rgb[2] = rgb[2].Divide(255.0f); // R
    if (b_meanstd)
    {
        // mean
        rgb[2] = rgb[2].Subtract(new Scalar(mean[0])); // B
        rgb[1] = rgb[1].Subtract(new Scalar(mean[1])); // G
        rgb[0] = rgb[0].Subtract(new Scalar(mean[2])); // R

        // std
        rgb[2] = rgb[2].Divide(std[0]); // B
        rgb[1] = rgb[1].Divide(std[1]); // G
        rgb[0] = rgb[0].Divide(std[2]); // R
    }
    Cv2.Merge(rgb, img);
    Cv2.Resize(img, img, resz);
}

 

 

 마지막으로 추론하는 Inference 함수입니다.

// 추론 과정
private void Inference(Mat image, out int label, out double prob)
{
    if (net.Empty())
    {
        MessageBox.Show("No Found Model!");
        label = -1; prob = 0;
        return;
    }
    if (image.Empty()) {
        label = -1; prob = 0; return;
    }
    Mat resizedImage = image.Clone();
    Mat blob = new Mat();
    NormalizeImage(ref resizedImage); 
    blob = CvDnn.BlobFromImage(resizedImage, 1.0f,
        new OpenCvSharp.Size(224, 224), swapRB:true, crop:false);

    net.SetInput(blob);
    string[] outBlobNames = net.GetUnconnectedOutLayersNames();
    Mat[] outputBlobs = outBlobNames.Select(toMat => new Mat()).ToArray();
    Mat matprob = net.Forward("output");

    // 최대 값의 구하기
    double maxVal, minVal;
    OpenCvSharp.Point minLoc, maxLoc;
    Cv2.MinMaxLoc(matprob, out minVal, out maxVal, out minLoc, out maxLoc);
    label = maxLoc.X;
    prob = maxVal * 100;
}

 

 이제 하이라이트인 Inference(추론) 함수에 대해서는 자세히 살펴보겠습니다.

1. 이미지를 Normalize 한 후에 BlobFromImage 함수를 통해 적절히 파라미터를 입력하고 OpenCV의 DNN에 사용되는 데이터 형식인 Blob 형태로 만들어줍니다. 

(참고1) Blob 형태는 NCHW 포맷으로, N:데이터 개수, C:채널 개수, H:Height, W:Width입니다.

 

2. 생성된 Blob은 SetInput 함수를 통해 입력으로 넣어줍니다.

 

3. 다음에 Forward(OutputName)으로 추론을 진행합니다. 여기서 OutputName은 이전 포스팅의 모델 코드에서 SaveToONNX 함수에 output_names으로 설정한 값을 넣으시면 됩니다. 제 포스팅대로 진행했다면 "output"을 넣으시면 됩니다.

# pytorch의 모델을 onnx 포맷으로 저장
def SaveToONNX(model, onnx_save_path):
	...
	output_names = ['output']
	...
    # 모델 변환
    torch.onnx.export(model,                     # 실행될 모델
    				...
                    output_names = output_names  # 모델의 출력값을 가리키는 이름
    )
...

 

4. Forward의 결과로 나온 값을 MinMaxLoc 함수를 이용해 최소, 최대 값을 구하고 위치(여기서는 라벨의 번호)와 값을 Inference 함수의 리턴 값으로 넘겨줍니다.

 

 

 짜잔! 프로그램 완성입니다! Face Detection으로 얼굴의 ROI를 잡아주고 해당 얼굴 위치에 마스크 착용 유무를 체크합니다!

전체 소스 코드

 

PyroNote/MaskDetection at main · 21june/PyroNote

My DeepLearning Test Repository. Contribute to 21june/PyroNote development by creating an account on GitHub.

github.com

(ResNet 모델 코드에 대한 설명은 나중에 따로 논문 요약하면서 코드에 대해 포스팅을 올려볼 생각이 있어서 이번 프로젝트에서는 패스합니다. 모델쪽은 주석으로 대략 정리는 해두었으니 참고하시면 될 것 같습니다. 해당 모델 코드는 혁펜하임님의 Legend 13 강의의 소스 코드를 참고했습니다.)

 

임포트 및 디바이스 설정

 다음과 같이 임포트를 진행했습니다.

# pytorch
import torch 
from torch import nn, optim 
from torchvision import datasets, transforms 
from torch.utils.data import Dataset, DataLoader, random_split 
from torch.optim.lr_scheduler import _LRScheduler
import torchvision.models as models

# matplotlib
import matplotlib.pyplot as plt

# etc
import os
import math
import random
from tqdm import tqdm  # 진행도 측정용
import onnx
import onnxruntime
import numpy as np

# GPU가 인식되면 GPU 사용, 아니면 CPU 사용
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
print(DEVICE)
print(torch.__version__)

 

 

상수 값

 학습에 사용될 파라미터 값들을 입력합니다. 적절하게 파라미터를 조절해서 학습을 진행하시면 됩니다. 특별하게 해당 상수 값을 사용한 이유는 없고 주로 초기값으로 많이들 사용해서 저도 동일하게 사용해봤습니다.

 

BATCH_SIZE = 64 # batch size
LR = 1e-4 # learning rate
EPOCH = 200 # input num of epoch
num_classes = 2 # input num of classes
criterion = nn.CrossEntropyLoss() # for Loss
model_type = "resnet18" # select model
dataset = "Mask_12K" # using dataset
dataset_path = f"/mnt/e/Base_Dataset" # dataset path
save_model_path = f"/mnt/e/Results/{model_type}_{dataset}_EPOCH{EPOCH}_LR{LR}.pt" # model path to save
save_onnx_path = f"/mnt/e/Results/{model_type}_{dataset}_EPOCH{EPOCH}_LR{LR}.onnx" # onnx path to save
save_lastepoch_model_path = f"/mnt/e/Results/{model_type}_{dataset}_{mean_std_type}_EPOCH{EPOCH}_LR{LR}_LASTEPOCH.pt" # model path to save
save_lastepoch_onnx_path = f"/mnt/e/Results/{model_type}_{dataset}_{mean_std_type}_EPOCH{EPOCH}_LR{LR}_LASTEPOCH.onnx" # onnx path to save

train_share = 0.8 # percentage of train dataset 
valid_share = 0.1 # percentage of val dataset
test_share = 0.1 # # percentage of test dataset

(path 관련 값들은 안바꾸시면 오류나니까 꼭 수정하시고 사용해주세요.)

 

데이터 셋

 데이터 셋을 적당히 세팅해줍니다. 먼저 transform을 통해 간단히 전처리를 해줍니다. Resize를 224, 224로 맞춰준 것은 ResNet이 224, 224 사이즈의 입력 이미지를 기준으로 나온 논문이기 때문입니다. 당연히 다른 사이즈를 넣어도 되지만 최적의 학습을 위해서는 가능하면 저 값을 맞춰주는게 좋습니다.

 참고로, ToTensor()를 하면 픽셀 별 RGB 값들이 0~1의 값으로 변경됩니다. 따라서 ToTensor() 이후 Normalize()를 해줘야하며 반대로 할 경우 제대로 동작하지 않을 수 있습니다.

 Normalize의 값은 학습 데이터(여기서는 이미지 데이터)들의 Mean, Std를 구해서 평균 값을 R,G,B 각각 넣어주시면 됩니다. ImageNet은 ImageNet 데이터셋의 값이며, Mask12K는 제가 직접 구한 Mean, Std 값입니다.

(+추가) 실제로 학습하고 실제 영상으로 테스트해보니 Normalize로 mean, std를 안넣은게 가장 결과가 좋았습니다. 

if dataset == "Mask_12K":
    transform = transforms.Compose(
        [
            transforms.Resize((224, 224)),
            transforms.ToTensor(),
        ]
    )

    if mean_std_type == "Mask12K":
        transform = transforms.Compose(
            transform.transforms + [transforms.Normalize(mean=[0.5703, 0.4665, 0.4177], std=[0.2429, 0.2231, 0.2191])]
        )
    elif mean_std_type == "ImageNet":
        transform = transforms.Compose(
            transform.transforms + [transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]
        )

 

 이어서, dataset을 적절한 위치를 지정해 로드한 후 앞서 입력한 share 비율만큼 나눠줍니다. 이후 사용자 정의 함수인 show_random_images를 사용해 랜덤하게 이미지를 로드한 후 라벨 값을 확인합니다. 데이터 라벨링이 적절하게 되어있는지 확인하는 과정이며 각 라벨링이 어떤 번호로 되어있는지 확인하기 위해 사용합니다.

    dataset_path = f"/mnt/e/Mask_12K" # 데이터셋 경로    
    train_DS = datasets.ImageFolder(root=dataset_path, transform=transform) 
    # Default: train 70%, valid 15%, test 15%
    train_size = int(train_share * len(train_DS))
    valid_size = int(valid_share * len(train_DS))
    test_size = len(train_DS) - train_size - valid_size
    train_DS, val_DS, test_DS = random_split(train_DS, [train_size, valid_size, test_size])

    train_DL = torch.utils.data.DataLoader(train_DS, batch_size=BATCH_SIZE, shuffle=True)
    val_DL = torch.utils.data.DataLoader(val_DS, batch_size=BATCH_SIZE, shuffle=True)
    test_DL = torch.utils.data.DataLoader(test_DS, batch_size=BATCH_SIZE, shuffle=True)

    train_loader = DataLoader(train_DS, batch_size=BATCH_SIZE, shuffle=True)
    val_loader = DataLoader(val_DS, batch_size=BATCH_SIZE, shuffle=True)
    test_loader = DataLoader(test_DS, batch_size=BATCH_SIZE, shuffle=False)
    
    # 적합하게 라벨링 되어있는지 랜덤으로 가져와서 테스트하는 용도
    dataloaders = { 'Train': train_DL, 'Valid':val_DL, 'Test': test_DL }
    show_random_images(dataloaders, n=10)

 라벨 0번이 마스크 착용, 1번이 마스크 미착용이네요. 라벨 값들과 이미지를 비교해보니 적절하게 잘 들어가 있는 모양입니다. 잘 기억해뒀다가 추론 할 때도 사용해봅시다.

 

모델 설정

 이후 모델을 선택합니다. ResNet은 레이어 깊이에 따라 여러 모델이 존재합니다. resnet 뒤에 붙은 숫자는 레이어의 수를 의미하니 높을수록 깊어져 학습이 더욱 정확해지지만 학습이 상당히 느려집니다. 이 프로젝트에선 깊은 단계까진 필요없고 resnet18정도로 진행해보겠습니다. 이후 모델의 형태를 텍스트로 확인합니다. 

# 사용할 모델 선택
if model_type == "resnet18":
    model = resnet18(num_classes=num_classes).to(DEVICE)
elif model_type == "resnet34":
    model = resnet34(num_classes=num_classes).to(DEVICE)
elif model_type == "resnet50":
    model = resnet50(num_classes=num_classes).to(DEVICE)
elif model_type == "resnet101":
    model = resnet101(num_classes=num_classes).to(DEVICE)
elif model_type == "resnet152":
    model = resnet152(num_classes=num_classes).to(DEVICE)
elif model_type == "resnet18_pretrained": # pytorch 모델 사용 + pretrained 사용
    model = models.resnet18(pretrained=True).to(DEVICE)
    num_features = model.fc.in_features
    model.fc = torch.nn.Linear(num_features, num_classes).to(DEVICE)
elif model_type == "resnet50_pretrained": # pytorch 모델 사용 + pretrained 사용
    model = models.resnet50(pretrained=True).to(DEVICE)
    num_features = model.fc.in_features
    model.fc = torch.nn.Linear(num_features, num_classes).to(DEVICE)

print(model) # 모델 구성 확인
x_batch, _ = next(iter(train_DL)) 
print(model(x_batch.to(DEVICE)).shape)
(Output)

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (stage1): Sequential(
    (0): BasicBlock(
      (residual): Sequential(
        (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
    )
    (1): BasicBlock(
      (residual): Sequential(
        (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (2): ReLU(inplace=True)
        (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (relu): ReLU(inplace=True)
...
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=512, out_features=2, bias=True)
)
torch.Size([64, 2])

 마지막 줄의 torch.Size([64, 2])의 경우, train dataloader에서 한 번의 iterator인 이미지 64(=BATCH_SIZE)개 만큼 가져와서 model에 추론한것의 shape를 확인한 것입니다. 64개 이미지 각각의 라벨별(마스크O, 마스크X 2가지 라벨) 확률이 들어가 있습니다.

 

(예시)

model(x_batch.to(DEVICE))의 [0,0] 값 = 첫 번째 이미지에서 마스크 쓰고 있을 확률

model(x_batch.to(DEVICE))의 [0,1] 값 = 첫 번째 이미지에서 마스크 안 쓰고 있을 확률

 

 

학습 및 검증

 학습에 앞서 몇 가지 변수를 추가했습니다.

optimizer = optim.Adam(model.parameters(), lr=LR)

# ReduceLROnPlateau # https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.ReduceLROnPlateau.html
# 후에 step에서 넣는 값(여기서는 val_loss)의 변화를 추적하여 LR 값을 조정하는 방식.
# 여기서는 val_loss가 연속적인 EPOCH 10(patience)회 동안 낮아지지(min) 않을 경우, 
# 새로운 LR 값을 LR * 0.1(factor)을 계산하여 생성한다. 단, 새로운 LR 값은 0(min_lr)을 넘어야한다.
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, threshold=1e-4, threshold_mode='rel', min_lr=0, verbose=False)

train_losses = []
val_losses = []

best_val_loss = float('inf')
optimizer 옵티마이저를 설정합니다. 여기서는 Adam을 사용합니다.
scheduler learing rate 값을 조절할 스케쥴러를 설정합니다. 상황에 따라 LR Scheduler를 안쓰는 경우도 있고 다른 알고리즘을 사용해도 되지만 여러 프로젝트를 봤을 때 ReduceLROnPlateau랑 CosineAnnealing 기법이 자주 사용되는 것 같습니다.
train_losses, val_losses plot에 각 EPOCH 별로 loss 값을 출력하기 위해 사용됩니다. 매 EPOCH마다 값이 저장됩니다.
best_val_loss val_loss가 낮아질 때마다 모델을 저장하기 위해서는 해당 값이 필요합니다. 

 

 

이제 본격적으로 학습에 진행합니다.

for ep in range(EPOCH):
    model.train() # train mode로 전환
    train_loss = 0.0

    with tqdm(train_DL) as tepoch: # 진행도 체크용
        # Training Loop
        for x_batch, y_batch in train_DL:
            tepoch.set_description(f"Epoch {ep+1} / {EPOCH}")
            x_batch = x_batch.to(DEVICE)
            y_batch = y_batch.to(DEVICE)

            optimizer.zero_grad() # gradient 누적을 막기 위한 초기화
            y_hat = model(x_batch) # inference
            loss = criterion(y_hat, y_batch)
            loss.backward() # backpropagation
            optimizer.step() # weight update

            train_loss += loss.item()

        train_loss /= len(train_DL)
        train_losses.append(train_loss)
        
        # eval mode로 전환
        model.eval()
        val_loss = 0.0
        with torch.no_grad(): # gradient 자동 계산 X / val, test땐 gradient 계산이 필요없으니
            for x_batch, y_batch in val_DL:
                x_batch = x_batch.to(DEVICE)
                y_batch = y_batch.to(DEVICE)
                y_hat = model(x_batch) # inference 결과
                loss = criterion(y_hat, y_batch) # loss check
                val_loss += loss.item()
        
        val_loss /= len(val_DL)
        val_losses.append(val_loss)        
        print(f"Epoch [{ep+1}/{EPOCH}], Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}")
        
        # LR Scheduler
        if scheduler is not None:
            # 앞서 확인했듯이 ReduceLROnPlateau는 매 사이클마다 확인하는 메트릭이 필요함. 여기서는 val_loss의 값을 기준으로 한다.
            if isinstance(scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau): 
                scheduler.step(val_loss)
            else:
                scheduler.step()

        # 베스트 모델만 저장함. 여기서 베스트 모델은 val_loss 값이 낮은 것.
        if val_loss < best_val_loss:
            best_val_loss = val_loss
            torch.save(model, save_model_path)
            SaveToONNX(model, save_onnx_path)
            
# 마지막 EPOCH Weight 저장
torch.save(model, save_lastepoch_model_path)
SaveToONNX(model, save_lastepoch_onnx_path, x_batch)

 코드의 큰 흐름은 다음과 같습니다.

(1) train - mode 변경 (train)

(2) train - dataloader를 통해 이미지 및 라벨 한 묶음(BATCH_SIZE=64) 가져와서 x_batch, y_batch에 넣기

(3) train - x_batch, y_batch로 순전파, 역전파 진행 후 train_loss 체크하고 weight 값 업데이트

(4) val - mode 변경 (eval)

(5) val - dataloader를 통해 이미지 및 라벨 한 묶음(BATCH_SIZE=64) 가져와서 x_batch, y_batch에 넣기

(6) val - x_batch, y_batch로 순전파, 역전파 진행 후 val_loss 체크하기 (train이 아니라서 weight 값 업데이트는 안함)

(7) schedular를 통해 lr(learning rate)값 업데이트 (선택)

(8) ONNX 데이터 저장

(9) 1~8번의 과정을 dataloader 마지막 iteration까지 반복한다.

 

학습 결과 그래프

 다음과 같이 EPOCH에 따른 train_loss, val_loss 값 그래프를 그려보겠습니다. 

# EPOCH 별 val, train loss 체크
plt.plot(range(1, EPOCH+1), train_losses, 'b')
plt.plot(range(1, EPOCH+1), val_losses, 'r-')
plt.xlabel('EPOCH')
plt.ylabel('Loss')
plt.title('Train vs. Val Loss')
plt.grid()

 위와 같은 그래프가 나옵니다. 처음에는 많이 요동치다가 EPOCH 80쯤부터 잠잠해집니다. 이 프로젝트는 EPOCH를 100번정도로 해도 충분한 것 같네요.

 

테스트

 테스트는 학습, 검증 과정과 상당히 유사합니다. 다만 테스트는 EPOCH가 1번 뿐이며, weight를 업데이트 해주는 등의 과정을 안해도 된다고 보시면 됩니다. 테스트는 학습한 값을 가지고 추론해서 나온 값을 확인하는 단순한 과정이므로 당연한거겠죠?

model.eval()

test_loss = 0.0
correct = 0
total = 0

# Test Loop
with torch.no_grad():
    for x_batch, y_batch in test_loader:
        x_batch = x_batch.to(DEVICE)
        y_batch = y_batch.to(DEVICE)
        y_hat = model(x_batch) # inference
        loss = criterion(y_hat, y_batch)
        test_loss += loss.item()
        
        _, predicted = torch.max(y_hat, 1)
        correct += (predicted == y_batch).sum().item()
        total += y_batch.size(0)

accuracy = 100.0 * correct / total
test_loss /= len(test_loader)

print(f"Test Loss: {test_loss:.4f}, Accuracy: {accuracy:.2f}%")

 

(Output)
Test Loss: 0.3155, Accuracy: 99.77%

 똑같이 loss와 accuracy를 출력하고 테스트가 끝납니다. 정확도 99.77%로 엄청 잘 나왔네요! 결과물 파일도 다음과 같이 잘 나온걸 확인할 수 있습니다. Resnet18은 43MB, Resnet50은 92MB정도 나오네요.

 

 다음 포스팅은 이번 학습의 결과물로 나온 파일(onnx)를 가지고 실제 어플리케이션(C#, WPF)에서 로드 후 추론까지 진행하는 코드를 살펴보겠습니다.

 딥러닝 공부하면서 개인 프로젝트 주제를 생각해봤습니다. 딥러닝 공부 후 첫 프로젝트인 만큼 단순하면서도 현실에서 쓰일만한게 뭐가 있을까 고민을 했습니다.

 요즘 다시 독감, 코로나 환자가 많이 발생하고 미세먼지도 심해서 마스크 착용 유무를 판단하는 모델을 만든다면 현실에서 유용하지 않을까 생각이 들어 이 주제로 선택했습니다. 

 

1. 추론 프로그램 환경

 추론용 프로그램은 C#의 WPF 프레임워크를 통해 개발합니다. 컴퓨터 사양은 크게 필요하지 않으며 웹캠이 하나 필요합니다. 노트북의 경우 내장된 웹캠을 이용하시면 됩니다. 혹은 이미지 파일을 불러와서 결과를 확인 할 수도 있습니다.

 

 C#의 NuGet 패키지로 아래와 같이 OpenCV 관련 패키지들을 추가해주었습니다. OpenCvSharp4 하위의 패키지들은 추가를 안하면 오류가 발생하더라구요. 오류가 발생하지 않는다면 굳이 추가해주지 않아도 좋습니다. 

    <PackageReference Include="OpenCvSharp4" Version="4.10.0.20241108" />
    <PackageReference Include="OpenCvSharp4.Extensions" Version="4.10.0.20241108" />
    <PackageReference Include="OpenCvSharp4.runtime.win" Version="4.10.0.20241108" />
    <PackageReference Include="OpenCvSharp4.Windows" Version="4.10.0.20241108" />
    <PackageReference Include="OpenCvSharp4.WpfExtensions" Version="4.10.0.20241108" />

 MFC나 자바 등 다른 언어 및 프레임 워크에서 개발하시더라도 값을 UI로 표현하는 부분만 각기 다를 뿐, 딥러닝 모델을 불러오고 추론하는 주요 부분들은 OpenCV의 함수를 사용하므로 약간의 수정을 거친 후 사용하시면 됩니다.

 

2. 학습 프로그램 환경

 학습 PC 환경은 CPU i7-12700, GPU RTX 3080, RAM 64GB가 달린 윈도우 데스크탑을 사용합니다. WSL(Window Subsystem Linux)를 통해 pytorch 1.13, pytorch-cuda 11.6 버전을 설치하여 GPU로 학습했습니다. 학습 프로그램에서 최종 결과물을 onnx 포맷의 파일로 변환하는 것까지 수행합니다. 이후 추론 프로그램에서 앞서 생성한 onnx 파일을 읽어와서 추론을 수행합니다. 다음과 같은 패키지를 사전에 받아주면 좋습니다.

패키지 명 버전
python 3.10.14
pytorch 1.13.0
pytorch-cuda 11.6
matplotlib 3.8.4
numpy 1.24.3
onnx 1.14.0
onnxruntime 1.17.1
tqdm 4.66.4

 

 모델은 ResNet만 사용했습니다. ResNet 중에서도 레이어가 가장 얕은, ResNet-18을 중점으로 테스트했습니다. 데이터셋이 그렇게 크지도 않고 레이어도 얕은데 생각보다 학습이 생각보다 오래 걸리더군요.. 사장님 4090 사주세요...

3. 데이터 셋 준비하기

 이제 데이터셋을 준비해봅시다. Kaggle에서 mask를 검색했더니 우리가 흔히 아는 마스크가 아닌, 마스킹과 관련있는 데이터들이 나오더군요. 그래서 'face mask'를 키워드로 검색해보니 이제서야 제대로 된 데이터셋들이 나옵니다. 다음 링크에 있는 데이터셋으로 선택했습니다.

 

Face Mask Detection ~12K Images Dataset

12K Images divided in training testing and validation directories.

www.kaggle.com

 아래와 같이 Download 버튼을 눌러 받을 수 있습니다만 로그인을 해야 다운로드 가능합니다. Kaggle에 데이터셋이 다양하고 여러 대회들도 있으며 남들이 짠 코드도 볼 수 있어서 편하므로 가입을 권장드립니다.

 이 데이터셋으로 선정한 이유는.. 여러 마스크 데이터셋을 봤지만 다른 데이터셋은 합성을 한 경우가 많았고, 영상 해상도가 너무 높거나 데이터수가 적은 케이스도 많았습니다. 이 데이터셋은 사이즈도 작고 파일도 1.2만개나 있고 대부분 합성이 아닌 실제 마스크를 쓴 사람의 사진 위주라 선택하게 되었습니다.

 

 이 데이터셋을 제 프로젝트에서 사용하려면 압축해제 후에 약간 수정이 필요합니다. 업로더가 친절하게 Train, Valid, Test마다 폴더를 구분해 데이터를 나눠주었습니다. 하지만 여기서는 마스크 낀 사람/마스크 안 낀 사람으로만 구분된 데이터셋을 만들고 매 학습마다 랜덤하게 Train, Valid, Test를 나누도록 하겠습니다. 

 아래 사진과 같이, Validation\WithMask, Train\WithMask, Test\WithMask의 사진들을 WithMask 폴더 한 곳에, Validation\WithoutMask, Train\WithoutMask, Test\WithoutMask의 사진들을 WithoutMask 폴더 한 곳에 모아두겠습니다. 

(왼쪽) 원본 데이터셋, (오른쪽) 합친 데이터셋

 

 간단한 프로젝트이므로 영상에 사람 얼굴이 하나인 케이스만을 고려하고자 합니다. 여유가 된다면 사람이 여러명인 영상을 처리하는 것도 해보려고 합니다. OpenCV의 Cascade Classifier나 DeepFace 라이브러리 등을 이용해서 얼굴만 따로 떼내면 각 얼굴마다 마스크 착용 유무를 판단할 수 있을 것 같습니다.

 

 

4. 결과물 (초안)

 현재까지 완성된 아웃풋입니다. 

 마스크를 쓰면 Great! You're wearing a mask! (확률(%))가 출력되고, 마스크를 안쓰면 Put on your mask quickly! (확률(%))가 출력됩니다. 고작 18개의 레이어로 구성된 모델일 뿐인데도 생각보다 꽤 정확했습니다. 거기다 손으로 가려도, 턱스크를 써도 마스크 착용이 아닌걸 잘 인식하네요. 시중에서 사용하기에는 더 다듬을 필요가 있겠지만 간단히 재미 용도로는 충분히 쓸만해 보였습니다.

 

 만들고보니 아무리 첫 프로젝트라 해도 너무 허접하고 별게 없어서 WPF 공부 할 겸 UI 기능이라도 더 추가할까 고민 중 입니다;;

 

5. 포스팅 안내

 포스팅 순서는 다음과 같이 진행됩니다.

[1] 소개 및 환경 세팅 (현재 포스팅)

[2] 학습 코드

[3] GUI 코드

[4] 결과 및 끄적끄적

 

 다음엔 pytorch 모델 코드에 대해 포스팅하겠습니다.

+ Recent posts