😊AI를 이용해서 어두운 이미지를 밝게 만들어보자

[gellston]

육아 휴직 중인데 심심하군요..

AI를 이용해서 어두운 이미지를 밝게 만드는 프로그램을 만들어보고 싶어졌습니다.

아래 이미지는 저조도 데이터셋 이미지인데 재미있어 보이는군요.

조금씩 만들어보면서 결과들을 업데이트 해보겠습니다.

[gellston]

가장 만만해 보이는 논문을 찾았습니다.

https://arxiv.org/pdf/2103.00860

요 녀석을 정독해 보면서 아래와 같은 순서로 구현을 해볼까 합니다.

1. pytorch를 이용해서 모델을 만듬
2. C++에서 돌릴 수 있게 inference 코드를 작성
3. C#으로 그것을 다시 랩핑 (마샬링방법과 C++/CLI 두가지 방법으로 래핑을 진행해서 장단점 정리)
4. C# WPF에 서비스로 밀어 넣어서 간단하게 이미지를 불러와 입력 이미지와 결과 이미지를 비교

근데.. 버릇이 참 무서운게 분명 휴가 중인데 눈이 로봇처럼 새벽이 되면 열리는군요..

[gellston]

너는 도대체 어떻게 동작 하는 거니?

Zero-DCE모델은 읽어 보니.. 입력 RGB 입력을 받으면 그 입력으로 딥러닝 모델을 통과해 추정한 곡선 커브용 파라미터와 딥러닝 모델의 입력으로 넣었던 x와 함께 곱하거나 더해서 최적의 밝기 곡선을 가진 이미지를 만드는것이 목적입니다.

논문 저자는 8번 반복해서 곱해서 최적의 밝기를 가진 이미지를 만들어냈습니다.

아.. 그리고 음.. 논문저자의 원문 repository도 참고했는데 저 커브 파라미터는 입력이미지가 500x500이라면 그 갯수만큼 따로 추정합니다. 이해가 안되서 한참을 봤는데… 픽셀마다 파라미터 weight가 독립이니 어두운 곳은 밝게 밝은 곳은 더 작은 가중치를 줘서 번지지 않게 할 수 있을 것 같다는 느낌적인 느낌이 드는군요. 만약 저 파라미터가 하나였다면 당연하겠지만 밝은곳과 어두운 곳을 따로 컨트롤 할 수 없겠지요 ㅠ

위에 설명한 것 처럼 모든 픽셀이 다른 가중치를 가지기 때문에 딥러닝이 조정한 파라미터 값들을 R,G,B 채널로 분리해서 시각화하여 heatmap으로 표현했을 때 어두운 곳은 많은 가중치, 밝은 곳은 적은 가중치를 곱하게 됩니다.

딥러닝 모델의 구조적 관점으로 관찰해보자

이건 뭐.. 전혀 복잡하지 않은 여러 컨볼루션을 적층하여 만든 단순한 모델이군요.

다만 아무리 단순하더라도 stride나 max pooling을 이용한 피쳐맵 축소가 없어서 메모리가 터져버릴 것 같은데.. 읽어보니 저 컨볼루션은 단순 컨볼루션이 아니라 google이 mobilenet이랑 xception모델에서 사용한 separable convolution을 이용했습니다.

separable convolution에 대한 설명을 적으면 너무 길어질 것 같아서 아래 링크로 대체하겠습니다.

블로그 운영하시는 분들이 글을 정말 잘 쓰시는군요 ….

Depthwise separable convolution 연산

그 외에 특별한 기술적인 부분은 없고 연산량을 줄이기 위해서 커브 파라미터 추정 시에 사용자가 지정한 scale값 만큼을 줄이는 작업을 하는군요.

코드를 뜯어보니.. 가로 세로 길이를 4배를 줄입니다. 면적으로 따지면 16분의 1로 줄어 들었다고 볼 수 있겠군요.

코딩하는 개발자가 바라보는 동작 원리

저는 딥러닝에 관심이 있는 사람이지 대학원을 다니거나 연구원은 아니기 때문에 수학을 정말 못합니다 -_-

오히려 C# 코딩이 좋은데 그럼 저 모델을 도대체 어떻게 이해해야 될 가 생각해봤습니다.

딱 맞는 정확한 설명은 아니지만 아래 그림처럼 직관적인 느낌이 그려지는군요..

Slog 태클과 의견공유… 댓글은 언제나 환영입니다.

[gellston]

구현한 저조도 개선 모델 Python코드

논문에 나온대로 구현하였고 학습을 걸어놓았습니다.
결과가 잘 나왔으면 좋겠군요..
이전 포스트에서 언급했듯이 이 모델을 학습시켜서 배포는 ONNX로 진행을 할 것입니다.
그 ONNX모델을 C++ ONNX라이브러리를 이용하여 로드해서 돌아가도록 만들 것이고.
그 이후에 C# 래핑 과정을 거쳐 UI에 시각적으로 표시할 예정입니다.
물론 누겟에 배포되어있는 유명한 ONNX C#라이브러리를 이용해서 추론하는것도 가능합니다.

Microsoft.ML.OnnxRuntime 1.24.2

아 그리고 제가 사용한 저조도 개선 데이터셋은 아래 링크에서 받으실 수 있습니다.

LOL Dataset

Separable Convolution Block

import torch
class DepthwiseSeparableConv(torch.nn.Module):
    def __init__(self, in_ch, out_ch):
        super(DepthwiseSeparableConv, self).__init__()
        self.depth_conv = torch.nn.Conv2d(in_ch, in_ch, kernel_size=3, padding=1, groups=in_ch)
        self.point_conv = torch.nn.Conv2d(in_ch, out_ch, kernel_size=1)

    def forward(self, x):
        return self.point_conv(self.depth_conv(x))

ZeroDCE Model

import torch
import torch.nn as nn
import torch.nn.functional as F



from model.block import DepthwiseSeparableConv


class ZeroDCEPP(nn.Module):
    def __init__(self, scale_factor=4, num_features=32):
        super(ZeroDCEPP, self).__init__()

        self.relu = nn.ReLU(inplace=True)
        self.scale_factor = scale_factor
        self.upsample = nn.UpsamplingBilinear2d(scale_factor=self.scale_factor)

        self.e_conv1 = DepthwiseSeparableConv(3, num_features) 
        self.e_conv2 = DepthwiseSeparableConv(num_features, num_features) 
        self.e_conv3 = DepthwiseSeparableConv(num_features, num_features) 
        self.e_conv4 = DepthwiseSeparableConv(num_features, num_features) 
        self.e_conv5 = DepthwiseSeparableConv(num_features * 2, num_features) # x3 + x4
        self.e_conv6 = DepthwiseSeparableConv(num_features * 2, num_features) # x2 + x5
        self.e_conv7 = DepthwiseSeparableConv(num_features * 2, 3)            # x1 + x6

    def apply_curve(self, x, x_r):
        for _ in range(8):
            x = x + x_r * (torch.pow(x, 2) - x)
        return x

    def forward(self, x):
        # 다운 스케일
        if self.scale_factor == 1:
            x_down = x
        else:
            x_down = F.interpolate(x, scale_factor=1/self.scale_factor, mode='bilinear', align_corners=False)


        # 특징 추출 레이어 시작 
        layer1 = self.relu(self.e_conv1(x_down))
        layer2 = self.relu(self.e_conv2(layer1))
        layer3 = self.relu(self.e_conv3(layer2))
        layer4 = self.relu(self.e_conv4(layer3))
        
        # Feature Concat
        layer5 = self.relu(self.e_conv5(torch.cat([layer3, layer4], 1)))
        layer6 = self.relu(self.e_conv6(torch.cat([layer2, layer5], 1)))
        layer7 = self.e_conv7(torch.cat([layer1, layer6], 1))
        

        x_r = torch.tanh(layer7)

        # 원본 사이즈로 다시 upsampling
        if self.scale_factor != 1:
            x_r = self.upsample(x_r)
        
        # 원본 이미지에 라이트맵을 곱함.
        enhance_image = self.apply_curve(x, x_r)
        
        return enhance_image, x_r

ONNX Model 배포를 위한 모델 코드

import torch


class OnnxModel(torch.nn.Module):
    def __init__(self, backbone:torch.nn.Module):
        super(OnnxModel, self).__init__()

        self.backbone = backbone


    def forward(self, x):
    
        ## 학습한 모델을 내보내기 할때 curve parameter는 inference시 필요가 없기 때문에. 
        ## OnnxModel용 클래스를 만들어서 curve를 제외한 결과만 리턴하도록 수정 
        
        x, curve = self.backbone(x)

        return x

Training Code

import torch
import torch.onnx
import numpy as np
import cv2
import os

from model.zerodcepp import ZeroDCEPP
from loss.zerodce_loss import ZeroDCETotalLoss
from dataset.lle_dataset import get_lle_loader
from model.onnx_model import OnnxModel

# GPU 사용 가능 여부 확인
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"현재 사용 중인 디바이스: {device}")

# Hyper Parameter
epochs = 50
learning_rate = 0.0001
weight_decay = 0.0001
batch_size = 8
scale_factor = 4
num_features = 32
image_width = 1024
image_height = 1024
image_channel = 3

dataset_path = "C://github//dataset//lol_dataset//our485//all"
weight_path = "C://github//Dot4Seminar//working//python//results//weights.pth"
onnx_model_path = "C://github//Dot4Seminar//working//python//results//model.onnx"


dummy_input = torch.randn(size=(1, image_channel, image_height, image_width)).to(device)

model = ZeroDCEPP(scale_factor=scale_factor, num_features=num_features)
model = model.to(device)
if os.path.exists(weight_path):
    state_dict = torch.load(weight_path, map_location=device)
    model.load_state_dict(state_dict)


dataloader = get_lle_loader(dataset_path, batch_size, resize_shape=(image_height, image_width))
total_batches = len(dataloader)


loss = ZeroDCETotalLoss().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)

temp_loss = 1000000
for epoch in range(epochs):
    avg_loss = 0

    model.train()
    for i, x_image in enumerate(dataloader):

        gpu_x_image = x_image.to(device)
        enhanced_img, curve_params = model(gpu_x_image)
        current_loss = loss(gpu_x_image, enhanced_img, curve_params)

        optimizer.zero_grad()
        current_loss.backward()
        optimizer.step()

        avg_loss += current_loss.item() / total_batches

    tensor_input_check = gpu_x_image[0]
    tensor_output_check = enhanced_img[0]
    # 1. CPU 이동 및 Numpy 변환
    input = tensor_input_check.detach().cpu().numpy()
    input = np.transpose(input, (1, 2, 0))
    input = (input * 255).astype(np.uint8)
    input = cv2.cvtColor(input, cv2.COLOR_RGB2BGR)

    # 1. CPU 이동 및 Numpy 변환
    output = tensor_output_check.detach().cpu().numpy()
    output = np.transpose(output, (1, 2, 0))
    output = (output * 255).astype(np.uint8)
    output = cv2.cvtColor(output, cv2.COLOR_RGB2BGR)


    # 5. 시각화
    cv2.imshow("original", input)
    cv2.imshow("output", output)
    cv2.waitKey(1) # 1ms 대기 (학습 루프 멈춤 방지)

    if temp_loss > avg_loss:
        temp_loss = avg_loss
        
        model.eval()
    
        onnx_model = OnnxModel(backbone=model)

        torch.save(model.state_dict(), weight_path)
        torch.onnx.export(
            onnx_model,                      # 실행할 모델
            dummy_input,                # 모델 입력 예시
            onnx_model_path,            # 저장 파일명
            export_params=True,         # 모델 파일 안에 학습된 파라미터 저장
            opset_version=11,           # Bilinear 연산을 안정적으로 지원하는 버전
            do_constant_folding=True,   # 상수 폴딩 최적화 (속도 향상)
            input_names=['input'],      # 입력 노드 이름 (C++에서 호출 시 사용)
            output_names=['output'],    # 출력 노드 이름
        )
        
    print('current avg loss = ', avg_loss)

[파란매]

솔직히 알아듣지 못하지만 대단하시네요 제가 목표가 AI 는 모르지만 @gellston 님같이
일차로 학습을 시키는 방법을 배우는것데 대단하세요

[gellston]

음… 딥러닝 너무 어려운것 같습니다.

[gellston]

학습한 모델을 추론

지난 포스트에서 학습한 모델을 아래의 코드를 이용해서 추론해보겠습니다.
추론시에는 ONNX라이브러리를 사용하지 않고 pytorch 모델의 저장된 weights를 로드하여 추론 하였습니다.
코드 동작은 저조도 이미지가 저장되어 있는 이미지를 리스트로 불러와서 순회하며 추론을 진행하며 opencv를 이용해서 시각화 및 정상 동작하는지 파일로 저장하여 확인했습니다.

모델 추론 코드

import torch
import numpy as np
import cv2
import os


from model.zerodcepp import ZeroDCEPP


# GPU 사용 가능 여부 확인
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"현재 사용 중인 디바이스: {device}")



# Hyper Parameter
scale_factor = 4
num_features = 32
image_width = 1024
image_height = 1024
image_channel = 3

dataset_path = "C://github//dataset//lol_dataset//our485//low"
weight_path = "C://github//Dot4Seminar//working//python//results//weights.pth"
output_dir = "C://github//Dot4Seminar//working//python//results//output_images"


dummy_input = torch.randn(size=(1, image_channel, image_height, image_width)).to(device)

model = ZeroDCEPP(scale_factor=scale_factor, num_features=num_features)
model = model.to(device)
if os.path.exists(weight_path):
    state_dict = torch.load(weight_path, map_location=device)
    model.load_state_dict(state_dict)

model.eval()

os.makedirs(output_dir, exist_ok=True)

file_list = os.listdir(dataset_path)
image_extensions = ('.jpg', '.jpeg', '.png', '.bmp')


for file_name in file_list:
    if not file_name.lower().endswith(image_extensions):
        continue

    full_path = os.path.join(dataset_path, file_name)
    input = cv2.imread(full_path)
    
    if input is None:
        continue

    h, w, _ = input.shape

    input_img = cv2.cvtColor(input, cv2.COLOR_BGR2RGB)
    input_img = cv2.resize(input_img, (image_width, image_height))
    input_img = input_img.astype(np.float32) / 255.0
    input_img = np.transpose(input_img, (2, 0, 1))
    
    input_tensor = torch.from_numpy(input_img).unsqueeze(0).to(device)

    with torch.no_grad():
        enhanced_tensor, _ = model(input_tensor)


    output = enhanced_tensor.squeeze(0).cpu().numpy()
    output = np.transpose(output, (1, 2, 0))
    output = (output * 255.0).clip(0, 255).astype(np.uint8)
    
    output = cv2.cvtColor(output, cv2.COLOR_RGB2BGR)
    output = cv2.resize(output, (w, h))


    save_path = os.path.join(output_dir, file_name)
    cv2.imwrite(save_path, output)


    cv2.imshow('input', input)
    cv2.imshow('output', output)
    

    cv2.waitKey(1)

시연 동영상

click image to open video

결과 이미지

#1 원본

#1 결과

#2 원본

#2 결과

#3 원본

#3 결과

일부 저조도가 아닌 밝은 이미지에서는 왜 오동작을 할가?

왜냐면 ZeroDCE의 학습 로스는 어두운 이미지를 밝게 만들도록 weights 들을 조정하지만 (curve parameters) 반대로 과하게 밝은 픽셀 부분을 조정하여 낮추는 설계는 들어가 있지 않아서 그런것 같습니다.
만약에 이 모델을 사용해야 한다면 평균 밝기가 어느 값 이상일때에는 사용하지 않도록 (굳이 저조도 상태가 아니기떄문에?) 예외처리를 한다거나 아니면 학습중에 설정하는 하이퍼파라미터를 조정하여 타겟 밝기를 너무 밝지 않도록 조정하는 방법이 있을 수 있겠네요 (해봤는데 잘안됩니다..)

[windowmini]

우오….. CCTV 스크린샷 이 어두울때 사용 하면… 대박 나는거 아님까 ?

음 대기업만 쓰려나

능력자 횽아네… .. 논문을 개발로…

[tkm]

생각보다 코드가 간단해서 onnx 변환만 되면 쉽게 사용할 수 있겠네요

[BigSquare]

@gellston

반대로 과하게 밝은 픽셀 부분을 조정하여 낮추는 설계는 들어가 있지 않아서 그런것 같습니다.

평균 밝기가 일정 이상일 때,

이미지 반전 → 로직 적용 → 결과물 반전

으로 한 번 해보는 것도 좋으리라 생각됩니다.

[gellston]

요즘 CCTV에 딥러닝 쓴다고 들었는데 더 좋은게 들어가 있지 않을가요?ㅠ 잘모르겠군요 거기 업계는 ㅠㅠ

[gellston]

네 맞습니다 논문 저자분이 간결하게 설계를 하셨더라구요
오래된 논문이지만 저 저도 논문에서 항상 reference로 나오는 논문같더군요.
onnx모델은 누겟으로 감싸서 만들때 같이 readme를 작성해서 같이 공유드리겠습니다 (공부용)

[gellston]

아 좋은 아이디어 같습니다.
C++ 래핑을 할건데 그때 worst케이스 이미지들을 모아서 되는지 실험해봐야겠군요.

대충 이런 느낌이군요?
다만 딥러닝이 저 반전된 이미지를 입력으로 받을때 어떻게 해석할지 (오동작) 해봐야 될 것 같네요
아마 잘 되리라 보는데… 만약에 반전이 안된다면 학습할 때 augmentation으로 픽셀 값 반전을 넣고 학습한 모델을 가지고 아이디어를 적용해보겠습니다.

의견 주셔서 감사합니다!

[gellston]

아까 의견 주신 거 댓글로 답변 드리다가 그러니까 저 그림을 그리다가?
문득 드는 생각이 이미 로스 함수에서는 인접 픽셀의 밝기차가(국소적인 밝기차) 과하지 않도록 제약을 주고있는데요.
거기에 더해서 평균 밝기가 내가 설정한 밝기로 따라가도록 설계가 되어있는데.
실험에서 입력으로 넣은 정상적인 이미지는 사람의 눈으로 보았을때 전체적인 글로벌한 밝기가
올라가 있는 상태인데 모델의 피쳐를 뽑는 컨볼루션 레이어들의 커널사이즈는 3x3으로 작기 때문에 전체 씬 해석 능력이 떨어지는 것도 어느부분 작용했을 거라고 생각이 드는군요 ㅠ
모델이 너무 좁게 보는게 아닌가 생각이 음..
그래서 말씀하신 반전 실험에 더해서 피쳐레이어에 커널 사이즈를 늘려서 테스트해보는 것도 해보도록 하겠습니다.

감사합니다!

[gellston]

어제밤에 작업한 것…

• 커스텀 메모리풀
• 커스텀 이미지 객체

왜 만들었는가?

저조도 모델을 돌리기 위해 필요한 것들을 생각해보니
일반적으로 이미지를 모델로부터 생성(저조도 개선된 이미지)받을 텐데 그럼 메모리가 늘어날테고
무한정 가지고 있을 수 없으니 다시 해제를 할 건데.. 음..
C#코드로 보면 빈번한 생성과 dispose가 있으면 메모리가 출렁출렁 거릴 것 같더군요 속도에도 안좋구요.
아무리 재미로 만든다지만.. 쩝 더 좋게 만들고 싶어서 밤중에 머리를 굴려서 메모리 풀도 만들어보았습니다.
이 메모리풀을 모델 내부에서 쓰거나 이미지를 파일로부터 불러와서 생성할 때에도 쓰면 좋을 것 같더군요.
그리고 또 생각해보니.. C++에서 이 메모리풀을 디자인해보면 보통 메모리 블럭을 pool 클래스로 반환을 할때 pool클래스의 멤버 함수를 호출해서 회수를 해줘야하는데 (예: free) 그것조차 사용하지 않고 사용자가 메모리를 쓰고버리면 pool로 자동으로 회수되도록 디자인해보고싶었습니다. 마치.. GC처럼..
그리고 이번에 만드는 C++ pool클래스나 image클래스의 모양을 그대로 따라해서 C#으로도 래핑을 진행할 예정입니다.

밤중에 만든 메모리풀 클래스는 아래와 같이 특별한 설계를 넣었습니다.

나만의 커스텀 메모리풀의 기능

• 메모리풀에 특정 사이즈 만큼 메모리를 요청하면 미리 생성된 똑같은 크기의 메모리 블럭을 찾아 메모리 토큰을 리턴
• 만약 메모리풀에 메모리 블럭이 생성되어 있지 않는다면 신규로 생성
• 메모리풀에 bin 사이즈를 사전에 설정하고 그 bin사이즈보다 같거나 작은 사이즈를 요청하면 해당 빈에 할당 되어 있는 메모리 블럭을 가리키는 메모리 토큰을 리턴
• 3번째 사항의 동작에 의해서 만약 사전에 설정한 bin사이즈와 사용자가 요청한 사이즈의 비가 메모리풀에 설정하는 efficient_rate 보다 작다면 사용자가 요청한 사이즈를 bin으로 신규 등록
  (※중요 : 내부단편화를 어느정도 방지)
• 모든 사용자가 요청하는 메모리 사이즈를 메모리풀 내부에서 사전에 설정한 단위 사이즈로
  align (※ 중요: 외부단편화를 어느정도 방지)
• free함수를 쓰지 않고 메모리를 요청한 후에 사용자가 방치하여 스코프를 벗어나면 자동으로 커스텀 메모리풀로 회수됨. (C# 래핑에서도 똑같은 동작을 하도록 만들것)

C++ 코드

#include <lle/memoryPool.h>
#include <lle/image.h>


int main()
{

    //메모리풀 클래스
    auto pool = lleapi::v1::memoryPool::create();
    while (true) {
        {
            //메모리블럭 토큰
            auto block = pool->acquire(3145728);
            {
                auto block = pool->acquire(3145728);
                {
                    auto block = pool->acquire(3145728);
                    {
                        auto block = pool->acquire(3145728);
                    }
                }
            }
        }
        //메모리풀을 통해 생성한 이미지
        auto image = lleapi::v1::image::create(1024, 1024, 3, pool);
    }
    
}

위 코드는 중괄호 스코프 내에서 생성된 메모리 block이 스코프를 벗어나 해제 되기 전 pool에 반환을 직접적으로 하지 않더라도 pool로 자동 회수되도록 만들었습니다. 그리고 이미지를 생성할때 필요한 메모리도 만약 이미지의 생성자에 pool을 인자로 주면 메모리풀에 요청한 메모리를 이미지가 사용하도록 만들었습니다.

결과

시몬스 침대처럼 출렁거리지 않고 재할당과 해제가 없는 것을 확인 할 수 있습니다. 속도는 측정하지 않았지만 아마도 빈번한 할당이 없으니 빠르지 않을까..싶습니다… 빨리 C#으로 똑같은 모양으로 래핑해서 결과를 보고싶군요 ㅠ

소스코드

GitHub - gellston/LLE: Low Light Enhancement Deeplearning Model Inference...

여기 Git에 저조도 모델을 돌릴 C++ API와 C# API를 만들고 누겟으로 배포할 생각입니다. 누겟으로 배포가 정상적으로 완료가 되면 그 다음에는 WPF UI에 올려서 뷰어도 만들어볼 생각입니다. 후! 어제밤에 작업한 저 메모리풀과 이미지도 올라가 있습니다.

[BigSquare]

@windowmini

CCTV 스크린샷 이 어두울때 사용 하면

CCTV는 적외선 라이트가 달려 있어, 굳이 어둡게 찍을 필요가 없습니다.

다만 안개 낀 날 사물을 식별하기 위해 비슷한 알고리즘이 적용된 (동영상) 감시 시스템이 이미 운용중에 있습니다. 영화처럼 막 선명하게 걸러내지는 못 해도, 기본 개념은 같습니다.

[gellston]

ONNX C++ 라이브러리를 이용해서 학습한 모델을 돌려보자.

어제 작업한 메모리풀과 이미지 클래스에 수정을 더해서 lle라는 저조도 개선 모델을 돌려줄 클래스를 만들었습니다.
lle와 image클래스 모두 memoryPool 인자로 받아서 생성하면 그 해당 클래스들이 부가적으로 메모리 할당을 시도할때 메모리풀에서 메모리를 사용하도록 했습니다.
(예: 이미지를 리사이즈한 결과, 딥러닝 모델의 예측 결과 이미지, 파일에서 이미지를 불러올때 등등)

코드

#include <lle/memoryPool.h>
#include <lle/image.h>
#include <lle/lle.h>

#include <iostream>


int main()
{

    try {
        auto pool = lleapi::v1::memoryPool::create();

        auto lle = lleapi::v1::lle::create(pool);
        lle->setup("C://github//LLE//python//results//model.onnx", lleapi::v1::device::cpu);

        auto input = lleapi::v1::image::imread("C://github//dataset//lol_dataset//our485//low//low_15.png", lleapi::v1::colorType::color, pool);
        auto output1 = lle->predict(input);
        lleapi::v1::image::imwrite("C://github//LLE//LLE//x64//Debug//result1.jpg", output1);

        auto output2 = lle->predict("C://github//dataset//lol_dataset//our485//low//low_15.png");
        lleapi::v1::image::imwrite("C://github//LLE//LLE//x64//Debug//result2.jpg", output1);

    }
    catch (std::exception ex) {

        std::cout << ex.what() << std::endl;
    }
}

결과

아래의 결과 이미지는 모두 위 C++ 클래스를 이용하여 추론한 결과를 파일로 저장하여 가져온 이미지입니다. python에서 추론한 결과와 크게 다르지 않음을 육안으로 확인 할 수 있습니다.

input.jpg

result1.jpg

소스코드

GitHub - gellston/LLE: Low Light Enhancement Deeplearning Model Inference...

고민거리

음… ONNX 모델을 누겟으로 같이 말아다가 배포할때에 빌드 아웃풋경로 쪽으로 던지는게 가능하긴한데요.
뭔가 사용자가 저 모델경로를 수동으로 설정한다는게 좀 아이러니하군요.
그렇게된다면 저 모델 inference를 도와주는 클래스는 저조도 특화 클래스가 아니라 모델을 돌려주는 녀석이 될텐데요.. (기술적으로 전혀 다른 모델을 넣어도 돌아갈것 같습니다..)
찾아보니 window resource로 바이러니를 저장해놓고 winapi로 가져다가 로드하는방법도있겠지만…

-_- LoadLibrary빼고는 정말로.. winapi를 싫어합니다. ㅠㅠ 무슨 느낌이 뭔지 아실 겁니다. 대문자 함수들 ㅠ

그래서 저런 리소스파일을 C++ dll 내부로 들여오는 방법이 있을가요?
사용해 보진 않았지만 특별한 툴들을 이용해서 바이트를 헤더로 바꿔서 같이 컴파일 하는 방법도 있던데
최신 방법이 궁금하군요 문득..

다음에 할 것

이제 C++ 라이브러리를 만들었으니 C#으로 래핑을 진행할 예정입니다. 애착이 가는 C++/CLI언어를 통해서 래핑을 진행해 볼텐데 공부겸 마샬링으로도 진행을 해봐서 장단점을 정리해보는 것도 좋을 듯 싶습니다.

[rkttu]

훌륭한 컨트리뷰션 감사드립니다!

C/C++ 코드 작성에 익숙하시니 검토해볼 수 있을만한 다음 Step으로, C#의 경우 JIT에 의존하지 않는 Naive AOT 빌드, 그리고 닷넷의 동적 메모리 인프라에 의존하지 않는 unsafe 프로그래밍을 검토해보시는 것도 괜찮을 것 같습니다.

C/C++ DLL 내부로 모델을 적재할 수 있는 “크로스 플랫폼 지향”이면서 “효율적”인 방법은 AI의 도움을 받아 찾아본 내용을 공유드려봅니다. 한 번 살펴보시면 어떨까 싶습니다.

---

머신러닝 모델처럼 거대한 데이터를 DLL(Windows)이나 ELF(Linux) 같은 바이너리 내부에 직접 포함시키는 방법은 여러 가지가 있습니다. 이를 보통 “Resource Embedding” 또는 “Binary Blobs” 처리라고 부릅니다.

가장 대표적이고 실무에서 쓰이는 방법들을 정리해 드립니다.

---

1. 링커(Linker)를 이용한 방식 (가장 범용적)

파일의 종류와 상관없이 바이너리 데이터 그 자체를 오브젝트 파일(.o 또는 .obj)로 변환하여 메인 프로그램과 합치는 방법입니다.

• GNU objcopy (Linux/ELF 중심):

  특정 파일을 섹션으로 포함된 오브젝트 파일로 바꿀 수 있습니다.

  Bash

  objcopy -I binary -O elf64-x86-64 -B i386 model.onnx model_data.o
  
  

  이렇게 하면 model_data.o 안에 _binary_model_onnx_start, _binary_model_onnx_end 같은 심볼이 생성되어 소스 코드에서 외부 변수처럼 접근할 수 있습니다.

• MSVC (Windows/DLL 중심):

  Visual Studio에서는 리소스 파일(.rc)을 사용합니다.

  코드 스니펫

  // model.rc
  IDR_MODEL_DATA RCDATA "model.onnx"
  
  

  프로그램 실행 중에 FindResource, LoadResource, LockResource API를 호출하여 메모리 포인터를 얻어옵니다.

2. 어셈블리(Assembly) incbin 사용

어셈블리어의 incbin 지시어를 사용하면 컴파일 타임에 파일을 직접 바이너리 데이터 섹션에 박아 넣을 수 있습니다.

코드 스니펫

; model.asm (NASM 예시)
section .rodata
global model_start
model_start:
    incbin "model.onnx"
model_end:

이 방식은 제어권이 매우 높고, 거의 모든 플랫폼에서 어셈블러만 있다면 사용 가능합니다.

3. 언어별 기본 기능 활용

최신 언어들은 이를 언어 차원에서 지원하기도 합니다.

• Rust: include_bytes! 매크로를 사용하면 컴파일 시점에 파일 내용을 &[u8] 배열로 가져옵니다.

  Rust

  const MODEL_DATA: &[u8] = include_bytes!("model.onnx");
  
  

• C++23: #embed 지시어가 도입될 예정(또는 일부 컴파일러 지원)입니다. 이전에는 xxd -i 같은 도구로 바이너리를 C 언어 배열(unsigned char model[] = {0x12, ...})로 변환해 포함하곤 했습니다.

---

주의할 점: 파일이 “매우 클” 경우의 문제

머신러닝 모델이 수 GB 단위로 커지면 바이너리에 직접 넣는 방식은 다음과 같은 문제에 봉착합니다.

1. 컴파일 속도 저하: 수 GB의 배열을 컴파일러가 처리하느라 빌드 시간이 엄청나게 늘어납니다.

2. 메모리 맵핑 효율: 바이너리가 실행될 때 전체 데이터가 프로세스 메모리에 로드되어야 하므로 메모리 낭비가 심할 수 있습니다.

3. 바이너리 크기 제한: Windows PE 포맷 등 일부 바이너리 포맷은 섹션 크기에 제한이 있을 수 있습니다.

대안: Memory-Mapped Files (mmap)

실제로 많은 머신러닝 라이브러리(TensorFlow, PyTorch, ONNX Runtime)는 모델을 바이너리에 박기보다는 별도 파일로 두고 Memory Mapping (mmap) 기술을 사용합니다.

• 장점: 파일을 메모리에 직접 올리지 않고, 필요할 때 OS가 필요한 부분만 페이징해서 가져옵니다.

• 사용법: 바이너리 안에는 모델 파일의 경로만 저장하고, 실행 시 mmap으로 연결하여 포인터처럼 사용합니다.

---

추천하는 방식:

• 모델 크기가 수십 MB 이하라면: **objcopy**나 Resource 파일 방식을 추천합니다. 배포가 파일 하나로 끝나서 매우 간편합니다.

• 모델 크기가 수백 MB ~ GB 단위라면: 바이너리에 넣지 말고 **외부 파일로 분리한 뒤 mmap**을 사용하는 것이 성능과 관리 면에서 유리합니다.

[rkttu]

참고로 Native AOT 빌드의 경우 단순히 JIT 컴파일만 피한다는 개념을 넘어섭니다. Windows, Linux, macOS를 대상으로 amd64, arm64 (+ s390x 등 특정 리눅스 배포판이 지원하는 아키텍처 포함) 대상으로 닷넷 런타임을 참조하지 않는 단일 실행 파일은 물론, 동적 라이브러리 (dll, so, dylib)와 정적 라이브러리 (lib, a) 파일 생성이 가능합니다.

[gellston]

파일을 헤더파일 행렬로 변환해서 넣거나 window resource로 밀어넣어서 가져오는건 알고있었는데
그 외에 많은 방법들이 있군여 (asm과 AOT?가 가능한줄 처음알았습니다.)
열심히 공부해서 반영해 보겠습니다. 감사합니다.

다행히 이번에 만든 모델은 작아서 헤더든 resource건 무리가 없어보이는데 AOT?를 알아봐야겠군요
다시 한번 답변 감사드립니다.!