sailorCat

point cloud 포인트 클라우드 RGB-d 센서 자율주행

sailorCat — Wed, 17 Jun 2026 03:45:43 +0900

RGB-D 센서는 기존의 컬러 이미지(RGB)에 각 픽셀의 깊이 정보(Depth, 디스턴스)를 함께 측정하는 카메라 센서

일반 카메라는 3차원 세상을 2차원 평면 이미지로만 담아내지만, RGB-D 카메라는 픽셀마다 카메라로부터 물체까지의 실제 거리(Z축)를 밀리미터(mm) 단위의 수치 데이터로 동시 수집

이 센서의 출력 결과물을 결합하면 곧바로 3차원 포인트 클라우드 데이터를 생성할 수 있다

1. RGB-D 데이터의 구조

RGB-D 센서는 촬영 시 두 가지 종류의 이미지를 동시에 만든다

RGB 이미지: 일반 카메라와 같은 컬러 사진 (가로 × 세로 × 3채널)
Depth(디스턴스) 이미지: 각 픽셀의 거리를 명암(보통 가까우면 밝고, 멀면 어두움)이나 물리적 수치(m 또는 mm)로 표현한 흑백 이미지 (가로 × 세로 × 1채널)

이 두 데이터를 합성하면 아래와 같은 4차원 공간 벡터 \([X, Y, Z, R, G, B]\) 배열

\(\text{RGB-D\ Pixel\ Vector}=\left[\begin{matrix}U_{\text{pixel}}&V_{\text{pixel}}\end{matrix}\right]+\text{Depth}(Z)\longrightarrow \left[\begin{matrix}X&Y&Z&R&G&B\end{matrix}\right]\)

2. 거리를 측정하는 2가지 핵심 기술

RGB-D 카메라는 레이저를 사용하는 대형 LiDAR 센서와 달리, 주로 다음과 같은 소형 카메라 모듈 기술을 사용

ToF (Time of Flight, 비행시간측정): 카메라에서 눈에 보이지 않는 적외선을 발사한 뒤, 물체에 부딪혀 돌아오는 시간을 측정 거리가 정밀하며 스마트폰(Apple iPhone Pro 시리즈의 LiDAR 스캐너)이나 산업용 로봇에 쓰인다
Structured Light (구조광): 특정 패턴의 적외선 그리드를 물체에 투사한 뒤, 물체 표면의 굴곡에 따라 패턴이 일그러지는 형태를 카메라로 분석해 거리를 계산 단거리가 매우 정밀하여 얼굴 인식(Apple FaceID)이나 실내 3D 스캔에 유리

3. 대표적인 RGB-D 센서 제품군

시장이나 연구실에서 가장 흔하게 접할 수 있는 대표적인 장비

Intel RealSense (인텔 리얼센스 시리즈): D435, D455 등 개발자 및 로봇 공학 연구에서 가장 표준적으로 쓰이는 RGB-D 카메라
Microsoft Azure Kinect: 마이크로소프트의 고해상도 ToF 카메라로, AI 기반의 신체 추적(Body Tracking)과 공간 스캔에 뛰어난 성능
Stereolabs ZED 카메라: 인간의 눈처럼 두 개의 렌즈(Stereo Vision)를 활용해 인공지능으로 깊이를 계산하는 RGB-D 센서로, 야외 장거리 측정에 강점

4. LiDAR 센서와의 차이점

구분RGB-D 카메라LiDAR 센서

측정 방식	카메라 이미지 센서 기반	레이저(펄스) 스캐닝 기반
시야각 (FoV)	카메라처럼 전방의 특정 각도만 촬영	회전형의 경우 360도 전 방위 측정 가능
색상 정보	RGB 내장 (기본 포함)	기본적으로 색상 없음 (카메라 추가 결합 필요)
외부 환경	햇빛이 강한 야외에서는 적외선 간섭으로 품질 저하	햇빛에 강하며 야외 및 장거리(100m~300m)에 특화
가격 및 크기	상대적으로 저렴하고 소형화 용이	고가 장비가 많고 차량/드론 탑재용 크기

5. 주요 활용 분야

로봇 자율 주행: 서빙 로봇이나 청소기가 전방의 장애물(의자 다리, 사람)의 형태와 거리를 입체적으로 인식
메타버스 및 AR/VR: 현실 공간을 그대로 스캔하여 3D 가상 공간(디지털 트윈)을 구축하거나, 가상의 가구를 방에 배치해 보는 앱에 사용
인체 모션 캡처: 사람의 관절 위치(X, Y, Z)를 실시간 3D 벡터로 추적하여 게임 캐릭터를 움직이거나 재활 치료용 자세 교정에 활용

RGB-D 센서는 실시간 차량 제어용 자율주행 센서로는 치명적인 한계가 있어, 주로 사용자 화면(내비게이션 UI), 차량 내부 모니터링, 또는 증강현실(AR) 헤드업 디스플레이(HUD)에 훨씬 적합

❌ 실제 자율주행 제어에 쓰이기 힘든 이유 (태생적 한계)

햇빛에 쥐약 (야외 노이즈): 대다수 RGB-D 카메라는 적외선 패턴(Structured Light)이나 적외선 플래시(ToF) 사용 태양광은 엄청난 양의 자연 적외선을 포함하고 있어서, 낮에 야외로 나가는 순간 햇빛에 묻혀 거리 측정이 완전히 불가능
짧은 측정 거리: LiDAR는 100m~300m 앞의 고속도로 장애물까지 잡아내지만, RGB-D 카메라는 성능이 좋아도 보통 5m~10m 내외(길어야 20m)만 측정할 수 있어 고속 주행 시 급제동 거리를 확보할 수 없다

⭕ 사용자 내비게이션 및 인포테인먼트 화면에서의 대활용

대신 컴퓨터 비전 기술과 결합하여 운전자에게 시각적 정보를 직관적으로 보여주는 영역에서는 최고의 효율을 낸다

AR(증강현실) 내비게이션 구현: 전방 카메라로 도로를 찍으면서, 깊이(Depth) 정보를 통해 앞차와의 거리나 도로 굴곡을 파악이를 통해 내비게이션 화면이나 HUD(전면 유리) 위에 "몇 미터 앞 차량 뒤를 따라가세요" 같은 가상 가이드라인을 오차 없이 정확한 3D 위치에 입혀줌
차량 내부 운전자 모니터링 (In-Cabin Sensing): 야외 태양광 영향을 받지 않는 차량 내부에서는 RGB-D 센서가 강력한 위력을 발휘합니다. 운전자의 얼굴 윤곽(3D 형태)과 눈동자 움직임을 실시간으로 3D 벡터 추적하여, 졸음운전을 하거나 전방 주시를 태만히 할 때 화면에 경고를 띄움
제스처 컨트롤 UI: 인포테인먼트 화면 앞에서 운전자가 허공에 손가락을 돌리면 볼륨이 조절되고, 손을 저으면 화면이 넘어가는 등의 3D 공간 모션 인식을 완벽하게 구현

point cloud 포인트 클라우드 LiDAR 데이터 형식

sailorCat — Wed, 17 Jun 2026 03:38:33 +0900

포인트 클라우드(Point Cloud)는 LiDAR 센서나 3D 스캐너로 수집한 3차원 공간상의 점(Point)들의 집합

각 점은 X, Y, Z의 기하학적 좌표를 가지며, 필요에 따라 RGB 색상이나 반사 강도 같은 추가 속성도 포함

공간 상의 이산적인 데이터 포인트 집합

LiDAR 포인트 클라우드 데이터 형식은 주로 LAS, LAZ, PCD, PLY 형식을 사용

LiDAR 센서는 단순히 위치(X, Y, Z) 정보뿐만 아니라 레이저의 반사 강도, 반사 횟수 등 센서 고유의 메타데이터를 함께 기록하기 때문에 일반 3D 모델링 파일과 다른 전용 포맷을 활용

1. 대표적인 LiDAR 데이터 파일 형식

포맷 확장자 주요 특징 및 용도형태 종류

.LAS	지형 정보(GIS) 표준 포맷 (미국사진측량원격탐사학회 ASPRS 표준)	이진(Binary)
.LAZ	LAS 파일을 압축한 포맷 (용량을 최대 90% 가까이 줄여줌)	이진(Binary)
.PCD	Point Cloud Library (PCL) 전용 포맷 (로봇 및 AI 연구용)	텍스트 / 이진
.PLY	다각형 메시 겸용 포맷 (컬러 정보 및 속성 확장이 자유로움)	텍스트 / 이진
.TXT / .XYZ	가장 단순한 텍스트 포맷 (호환성이 좋으나 대용량에 비효율적)	텍스트

2. LiDAR 데이터 벡터 구조 (LAS 구조 기준)

LiDAR 데이터는 한 점당 다음과 같은 확장된 형태의 벡터 데이터로 저장

\(\text{LiDAR\ Point\ Vector}=\left[\begin{matrix}X&Y&Z&I&R_{n}&N_{r}&C&\alpha &\dots \end{matrix}\right]\)

X, Y, Z (위치): 지구상의 절대 좌표(UTM 등) 또는 센서 기준의 상대 좌표 (단위: m)
Intensity (강도): 레이저가 물체에 부딪혀 돌아온 빛의 세기 (재질 식별용)
Return Number (반사 순서): 하나의 레이저 펄스가 여러 물체(예: 나뭇잎 → 땅)에 부딪혀 돌아올 때 몇 번째 신호인지 기록 (\(R_{n}\))
Number of Returns (총 반사 횟수): 해당 레이저 펄스가 총 몇 번 분할되어 돌아왔는지 기록 (\(N_{r}\))
Classification (분류): 점이 속한 객체 종류 (0: 미분류, 1: 가공되지 않음, 2: 지면, 3: 낮은 식생, 5: 높은 식생, 6: 건물 등)
Scan Angle (스캔 각도): 레이저가 발사된 거울의 회전 각도 (α)

3. 실제 데이터 저장 예시

이진(Binary) 포맷 (LAS/LAZ/PCD Binary)

컴퓨터가 빠르게 읽을 수 있도록 0과 1의 바이트 구조로 정렬되어 있어 사람이 직접 메모장으로 읽을 수 없습니다. 대용량 LiDAR 데이터를 실시간 처리할 때 필수

텍스트(ASCII) 포맷 (PCD ASCII / XYZ 예시)

헤더 구조 뒤에 공백으로 구분된 벡터 데이터가 나열됩니다.

text

# .PCD 파일 포맷 예시
VERSION 0.7
FIELDS x y z intensity return_number classification
SIZE 4 4 4 4 1 1
TYPE F F F F U U
COUNT 1 1 1 1 1 1
WIDTH 3
HEIGHT 1
VIEWPOINT 0 0 0 1 0 0 0
POINTS 3
DATA ascii
35.124 128.543 12.45 85 1 2
35.126 128.545 12.48 12 1 2
35.120 128.540 25.10 45 2 6

4. 자율주행 vs 지형 측량(GIS)의 포맷 차이

지형 측량 / 드론 매핑: 드론이나 항공기 LiDAR로 수집한 광범위한 지역 데이터는 국토교통부나 내비게이션 지도 제작 시 LAS/LAZ 포맷
자율주행 연구 (원격 센싱): ROS(로봇 운영체제) 환경이나 고정형 LiDAR 센서에서 실시간으로 들어오는 데이터 스트림은 주로 PCD 포맷이나 매 프레임별 Raw Binary Matrix 형태로 처리

포인트 클라우드 데이터에서 RGB 값은 각 점(Point)의 실제 색상 정보를 나타냅니다. 3D 스캐닝을 할 때 레이저로 위치를 측정하는 동시에, 내장된 컬러 카메라로 사진을 찍어 각 점의 좌표와 색상을 1:1로 매칭하여 저장

1. RGB 값의 표현 방식 (벡터 구조)

데이터 파일 내에서 RGB 값은 주로 두 가지 형태 중 하나로 표현

정수형 (0 ~ 255): 가장 직관적이고 흔한 형태 (예: [255, 0, 0]은 순수한 빨간색)
정규화된 실수형 (0.0 ~ 1.0): 딥러닝 입력 데이터나 특정 3D 그래픽 엔진에서 처리하기 쉽도록 255로 나눈 값 (예: [1.0, 0.0, 0.0])

데이터 배열 예시 (XYZ + RGB)

python

[
  #  [    X,     Y,     Z,    R,   G,   B ]
  [ 1.25, 3.42, 0.88, 255,   0,   0 ],  # 빨간색 점 (예: 소화전)
  [-0.45, 2.11, 1.50,   0, 255,   0 ],  # 초록색 점 (예: 나뭇잎)
  [ 0.12, 1.05, -0.2, 255, 255, 255 ]   # 흰색 점   (예: 차선 바닥)
]

2. LiDAR와 RGB: 센서 종류에 따른 차이점

모든 LiDAR가 RGB 값을 기본으로 수집하는 것은 아님

일반 LiDAR (RGB 없음): 자율주행차 지붕에 달린 일반적인 LiDAR는 레이저만 쏘기 때문에 위치(XYZ)와 반사 강도(Intensity)만 수집 색상 정보는 없다
카메라 융합형 LiDAR (RGB 있음): 드론 매핑용 고가 LiDAR나 iPhone의 LiDAR 스캐너처럼 카메라가 함께 장착된 장비는 레이저 좌표에 카메라의 픽셀 색상(RGB)을 실시간으로 입혀서 저장

3. 파일 포맷별 RGB 저장 형태

PLY / OBJ (3D 그래픽 포맷): 점 하나마다 X Y Z R G B 형태로 텍스트나 이진 데이터로 정직하게 기록
PCD (Point Cloud Library 포맷): 메모리와 처리 속도를 아끼기 위해 R, G, B 3개 바이트(각 8비트)를 하나로 묶어 32비트 부동소수점(Float) 하나로 압축하여 저장하기도 한다
- 예시: RGB 값을 하나의 정수 4294967295 같은 형태로 묶어서 1개의 열로 표현
LAS / LAZ (지형 측량 표준): 헤더 옵션에 따라 RGB 필드를 활성화할 수 있으며, 측량 장비에 따라 0~255가 아닌 16비트(0 ~ 65535) 범위의 고해상도 RGB 값을 저장하기도 한다

4. 포인트 클라우드에서 RGB가 중요한 이유

시각적 직관성: 데이터 분석가나 작업자가 3D 모델을 볼 때, 흑백이나 단색보다 실제 색상이 보여야 물체를 훨씬 쉽게 식별합니다.
AI 객체 인식(Semantic Segmentation): 자율주행이나 공간 인식 AI를 학습시킬 때, 형태(XYZ) 정보만 주는 것보다 색상(RGB) 정보를 함께 주면 "바닥에 그려진 흰색 차선"이나 "빨간색 표지판"을 훨씬 정확하게 구별

LiDAR, Light Detection and Ranging 라이다 자율주행 로봇 재난감지 지리정보 거리감지

sailorCat — Wed, 17 Jun 2026 03:17:58 +0900

라이다(LiDAR, Light Detection and Ranging)는 레이저 펄스를 발사하여 대상체에 부딪혀 돌아오는 시간을 측정함으로써 정밀한 3차원 거리와 형상을 파악하는 원격 감지 기술

레이더(Radar)보다 파장이 짧은 빛을 사용하여 주변 환경을 고해상도의 3차원 포인트 클라우드(점군) 데이터로 시각화

https://www.youtube.com/watch?v=xLtolcT-nRM

공식 가이드

https://www.cvat.ai/resources/blog/3d-point-cloud-annotation

Point Cloud Annotation: A Complete Guide to 3D Data Labeling | CVAT Blog

3D point cloud annotation explained. Our in-depth article walks through applications in computer vision, and how to efficiently label 3D data. Published On: Mar 31, 2026

www.cvat.ai

핵심 원리

발사 및 반사: 센서에서 발사된 레이저 빔이 주변의 물체에 부딪혀 반사되어 돌아옵니다.
시간 측정: 빛의 속도를 활용하여 레이저가 센서를 떠나 돌아오는 데 걸린 시간을 계산합니다. (거리 = 속도 × 시간 ÷ 2)
3D 매핑: 수백만 개의 데이터를 실시간으로 조합하여 주변 환경의 정밀한 3D 지도를 생성합니다.

️ 주요 활용 분야

자율주행 및 로봇 공학: 차량과 로봇의 '눈' 역할을 하며, 주변 보행자, 차량, 도로 시설물과의 거리를 입체적으로 인지합니다.
지리 정보 및 측량: 항공기나 드론에 장착하여 지형, 산림, 도시 인프라의 정밀한 3D 지도를 제작합니다.
재난 감지 및 건설: 산사태 예측, 홍수 모델링, 교량 등 건축물의 구조적 변위 분석에 활용됩니다.

자율주행 개발자 관점에서 라이다(LiDAR)는 단순히 "거리를 재는 센서"가 아니라, 3차원 공간의 기하학적 정보(Geometry)를 실시간으로 제공하는 가장 신뢰도 높은 소스(Ground Truth)입니다.

개발자가 자율주행 소프트웨어 파이프라인(Perception-Localization-Planning)을 구축할 때 라이다 데이터(Point Cloud)를 활용하는 핵심 분야와 구현 방식

1. 3D 환경 인지 (Perception) 및 객체 검출

카메라는 2D 이미지를 기반으로 거리를 '예측'해야 하지만, 라이다는 물체의 정확한 3D x, y, z 좌표를 즉시 반환합니다.

3D Object Detection (3차원 객체 검출):
- 구현: 포인트 클라우드를 입력받아 주변 차량, 보행자, 이륜차 등의 3D Bounding Box(위치, 크기, 헤딩 각도)를 추정합니다.
- 활용 모델: PointPillars, Second, PV-RCNN 같은 3D 딥러닝 백본 네트워크를 사용하여 텐서 변환 후 객체를 검출합니다.
Semantic Segmentation (의미론적 분할):
- 구현: 점 하나하나가 도로(Road), 인도(Sidewalk), 빌딩, 차량 중 어디에 속하는지 클래스를 분류합니다.
- 활용: 도로의 바닥면을 분할하여 차량이 주행 가능한 영역(Free Space)을 계산하는 데 필수적입니다.
Unidentified Obstacle Detection (비정형 장애물 검출):
- AI가 학습하지 못한 물체(예: 도로 위의 박스, 타이어 파편)라도 라이다는 기하학적 형태를 그대로 잡기 때문에, 카메라 딥러닝의 엣지 케이스(Edge Case)를 보완하는 안전장치로 쓰입니다.

2. 고정밀 측위 및 맵핑 (Localization & Mapping)

차량이 GPS 음영 지역(터널, 빌딩 숲)에서도 센티미터(cm) 단위로 자신의 위치를 찾아내도록 만듭니다.

SLAM (Simultaneous Localization and Mapping):
- 구현: 차량이 이동하면서 받아오는 실시간 포인트 클라우드 프레임을 연속적으로 매칭(Registration)하여 3차원 공간 지도를 동시에 그립니다. LeGO-LOAM, Fast-LIO 등의 알고리즘이 자주 쓰입니다.
Point Cloud Registration (점군 정렬):
- 구현: 현재 스캔한 데이터와 기구축된 고정밀 지도(HD Map)의 형태를 ICP(Iterative Closest Point)나 NDT(Normal Distributions Transform) 알고리즘으로 비교·정렬하여 차량의 정확한 6자유도(6-DoF) 위치를 추정합니다.

3. 센서 퓨전 (Sensor Fusion)

라이다는 형태와 거리 인지에는 강하지만 색상, 질감, 텍스트(표지판, 신호등) 인지에는 취약합니다. 이를 카메라와 융합하는 파이프라인을 설계합니다.

Early Fusion (초기 융합 / 데이터 레벨):
- 카메라의 2D 픽셀과 라이다의 3D 포인트를 물리적 캘리브레이션(Calibration) 매트릭스를 통해 투영(Projection)시켜, 색상 정보(RGB)를 가진 3D 포인트 클라우드(RGB-D)를 만들어 입력 레이어로 사용합니다.
Late Fusion (후기 융합 / 객체 레벨):
- 카메라 딥러닝 모델이 뽑은 2D Bounding Box와 라이다 모델이 뽑은 3D Bounding Box를 헝가리안 알고리즘(Hungarian Algorithm)이나 칼만 필터(Kalman Filter)를 이용해 매칭하여 객체의 정확도를 최종 확정합니다.

4. 시뮬레이션 및 데이터 라벨링 자동화 (Simulation & MLOps)

실제 도로 테스트 전에 소프트웨어를 검증하고 데이터셋을 구축할 때 대단히 유용합니다.

Auto-Labeling (자동 라벨링 알고리즘):
- 사람이 카메라 이미지에서 수천 장의 박스를 치는 것은 비효율적입니다. 라이다 SLAM으로 구축된 3D 포인트 클라우드 시퀀스를 앞뒤로 역추적(Backward/Forward Tracking)하여 3D 객체의 궤적을 만들면 수많은 카메라 이미지에 3D Bounding Box를 자동으로 투영시켜 라벨링 공수를 기하급수적으로 줄일 수 있습니다.

개발자 입장에서 고려해야 하는 현실적인 이슈

데이터 스파시티 (Sparsity): 거리가 멀어질수록 레이저 점 사이의 간격이 넓어져 객체 형태를 알아보기 어렵기 때문에 다운샘플링(Voxel Grid Filter) 및 데이터 보간 처리가 중요합니다.
연산 복잡도 (Computation Cost): 초당 수십만~수백만 개의 점(Point)이 들어오기 때문에, 이를 실시간(최소 10~20Hz 이상)으로 처리하기 위해 C++ 기반의 PCL(Point Cloud Library)나 GPU 가속(CUDA, TensorRT) 최적화가 필수적입니다.
노이즈 필터링 (Noise Filtering): 눈, 비, 안개, 먼지 등이 레이저를 교란시켜 허위 포인트(Ghost Lines)를 만듭니다. 이를 걸러내는 주행 환경별 필터 아키텍처 설계가 필요합니다.

4. 시뮬레이션 및 검증 단계

자율주행 시뮬레이션 및 데이터 라벨링 자동화 파이프라인에서 오토 라벨링(Auto-labeling) 결과물의 정답(Ground Truth) 여부를 검증하는 단계를 'QA(Quality Assurance) 및 검증(Validation) 단계'라고 합니다.

이 단계는 알고리즘이 자동으로 생성한 3D Bounding Box나 세그멘테이션 데이터의 오류를 찾아내고 수정하는 과정입니다. 개발자와 데이터 엔지니어는 라이다 어노테이션(LiDAR Annotation) 툴을 활용하여 다음과 같은 작업을 수행합니다.

1. 3D Bounding Box 정밀 정착 (Tightness & Orientation 튜닝)

알고리즘이 물체 주변에 대략적으로 친 박스의 크기, 위치, 방향을 센티미터(cm) 단위로 미세 조정합니다.

Tightness 검증: 3D 박스가 차량이나 보행자의 실제 라이다 점(Point)들에 딱 맞게 밀착되었는지 확인합니다. 박스가 너무 크면 가상의 공간을 물체로 인식하고, 너무 작으면 충돌 위험이 생깁니다.
Heading(방향) 수정: 차량이 진행하는 앞방향(Yaw 각도)이 맞는지 검증합니다. 라이다 데이터만으로는 차의 앞뒤 구분이 어려울 때가 많으므로, 동기화된 카메라 이미지(Camera-LiDAR Fusion View)를 교차 확인하며 차량의 정확한 헤딩을 맞춥니다.

2. 시간 연속성 검증 (Temporal Consistency & Tracking Check)

시퀀스(동영상처럼 이어지는 프레임) 데이터에서 물체의 움직임이 자연스러운지 확인합니다.

프레임 간 튀는 현상(Jittering) 제거: 1번 프레임과 2번 프레임 사이에서 차의 크기가 갑자기 바뀌거나, 위치가 순간 이동하듯 튀는 현상을 잡습니다. 보간(Interpolation) 알고리즘을 적용한 후, 사람이 수동으로 매끄럽게 다듬습니다.
ID Switching 오류 수정: 추적 중이던 A 차량이 반대편 차량에 가려졌다가 다시 나타났을 때, 오토 라벨러가 이를 새로운 B 차량으로 인식하는 오류(ID 스위칭)를 잡아내어 하나의 고유 ID로 묶어줍니다.

3. 클래스 오분류 수정 (Classification QA)

라이다 점군 데이터의 형태만 보고 알고리즘이 물체의 종류를 잘못 판단한 것을 바로잡습니다.

유사 형태 구분: 예를 들어 길가에 서 있는 '전신주'나 '가로수'를 '보행자'로 오인했거나, '대형 SUV'를 '트럭'으로 분류한 경우를 찾아내어 올바른 레이블(Label)로 수정합니다.

4. 고스트 현상 및 노이즈 제거 (Noise & Ghost Points Filtering)

환경 요인으로 인해 발생한 불필요한 라이다 점들을 정답 데이터에서 제외합니다.

환경 노이즈 제거: 비, 눈, 안개, 또는 차량 배기가스로 인해 공중에 찍힌 가상의 점(Ghost points)들이 오토 라벨러에 의해 장애물로 오인되어 박스가 쳐진 경우, 이를 과감히 삭제합니다.
바닥면(Ground) 오인 수정: 도로의 연석(Curb)이나 과속방지턱, 경사로의 꺾이는 부분을 장애물 박스로 잘못 지정한 것을 해제합니다.

5. 엣지 케이스 및 유실 데이터 수동 복구 (Edge Case & Missing Object Recovery)

알고리즘이 완전히 놓친 물체를 사람이 직접 찾아내어 채워 넣습니다.

원거리/희소 데이터(Sparse Points) 복구: 차량에서 50m~100m 이상 떨어진 물체는 라이다 점이 몇 개 찍히지 않아 오토 라벨러가 감지하지 못합니다. 검증 단계에서는 카메라 뷰와 대조하며 점이 2~3개뿐이더라도 명확한 장애물이라면 수동으로 3D Box를 생성해 줍니다.
비정형 객체 레이블링: 휠체어, 유모차, 킥보드를 탄 사람, 도로 위 낙하물 등 빈도가 낮은 엣지 케이스를 정확히 정의해 줍니다.

️ 검증 단계에서의 엔지니어링 워크플로우

보통 대량의 데이터는 CVAT, PCAT, Supervisely 같은 전문 3D 포인트 클라우드 어노테이션 툴을 사용하여 아래 이미지와 같은 멀티뷰 화면을 보며 검증합니다.

┌────────────────────────────────────────────────────────┐
│ [Top-Down / Bird's Eye View]   [Front / Side 3D View]   │
│ ㆍ ㆍ ㆍ┌───────┐ㆍ ㆍ ㆍ       ㆍ ㆍ ㆍ ㆍ ㆍ ㆍ ㆍ ㆍ  │
│ ㆍ ㆍ ㆍ│     │ㆍ ㆍ ㆍ       ㆍ ㆍ  ◢███◣ ㆍ ㆍ ㆍ ㆍ  │
│ ㆍ ㆍ ㆍ└───────┘ㆍ ㆍ ㆍ       ㆍ ㆍ  ◥███◤ ㆍ ㆍ ㆍ ㆍ  │
├────────────────────────────────────────────────────────┤
│ [Synchronized Camera Image View]                       │
│ ┌──────────────────────────────────────────────────┐   │
│ │  [   Detected Car ]                             │   │
│ └──────────────────────────────────────────────────┘   │
└────────────────────────────────────────────────────────┘

자동 검증 스크립트 실행: 3D Box 간의 충돌(갑자기 두 박스가 겹침), 물리적으로 불가능한 속도 변화 등을 파이썬 스크립트로 1차 필터링합니다.
시각적 교차 검증 (Cross-Validation): 엔지니어가 탑다운 뷰(Bird's Eye View), 3D 측면 뷰, 카메라 투영 뷰를 동시에 보면서 오토 라벨링된 박스의 경계면을 마우스로 잡고 정밀하게 맞춥니다.
최종 메타데이터 검수: 수정을 마치면 객체의 가려짐 정도(Occlusion), 잘림 정도(Truncation) 같은 메타데이터 속성 값이 올바르게 산출되었는지 확인하고 데이터셋 빌드에 포함시킵니다.

️ 검증 엔지니어가 알아야 할 핵심 소프트웨어 조작법

영상을 보시면 소프트웨어 인터페이스가 크게 세 가지 화면(Multi-View)으로 쪼개져 유기적으로 움직이는 것을 볼 수 있습니다.

1. 3D 단축키를 이용한 Bounding Box 6-DoF 미세 조정

작업: AI가 생성한 박스를 클릭하면 X, Y, Z축 이동축과 회전축(Yaw 기즈모)이 활성화됩니다.
조작: 마우스 드래그나 키보드 방향키(W, A, S, D 등)를 이용해 박스의 크기를 물체 겉면에 딱 맞추고, 차량의 헤딩(방향) 화살표를 주행 방향으로 회전시킵니다.

2. 탑다운 뷰(BEV, Bird's Eye View) 중심의 검수

작업: 라이다 데이터는 평면에서 볼 때 물체의 경계면이 가장 명확합니다.
조작: 마우스 휠로 BEV 화면을 확대/축소하면서 차량의 정면 점군과 후면 점군이 3D 큐보이드(Cuboid) 벽면에 일치하는지 스캔합니다.

3. 카메라 투영(Camera Projection)을 통한 시각적 교차 검증

작업: 라이다 점만으로는 이 물체가 세단인지, SUV인지, 혹은 표지판 기둥인지 구분이 안 될 때가 많습니다.
조작: 소프트웨어 한쪽에 연동된 카메라 이미지를 보며 마우스로 라이다 박스를 변경하면, 카메라 이미지 위 2D 박스도 실시간으로 연동되어 움직입니다. 이를 통해 물체의 클래스(Class)가 맞는지 텍스트나 형상을 보고 최종 확정합니다.

4. 시퀀스 트래킹 및 보간(Interpolation) 연산

작업: 100프레임 동안 움직이는 차량을 프레임마다 일일이 검수하는 것은 불가능합니다.
조작: 핵심 프레임(Keyframe)인 1번 프레임과 10번 프레임의 박스만 엔지니어가 검증해 주면, 소프트웨어가 그 사이(2~9번 프레임) 차량의 궤적을 선형 보간 알고리즘으로 자동 계산하여 채워 넣습니다. 검수자는 프레임을 Space 바로 재생하며 튀는 구간만 멈춰서 수정합니다.

3D 라이다 어노테이션 툴 영상 주소

1. CVAT (Computer Vision Annotation Tool) [1]

인텔에서 개발한 전 세계에서 가장 유명한 오픈소스 이미지/3D 데이터 라벨링 툴입니다. 실제 프로그램 인터페이스(메인 3D 뷰, 탑/사이드/프론트 뷰, 카메라 연동 화면)를 다루는 정석적인 방법을 확인할 수 있습니다.

실제 조작법 및 기능 소개 영상: CVAT 공식 3D 포인트 클라우드 가이드 (YouTube)
텍스트 매뉴얼 및 단축키 안내: CVAT 공식 블로그 가이드 [1, 2, 3]

2. BasicAI

자율주행용 센서 퓨전(라이다 + 카메라) 및 AI 기반 오토 라벨링 기능이 잘 구현되어 있는 대표적인 클라우드 기반 플랫폼입니다. [1]

라이다-카메라 퓨전 데이터 어노테이션 영상: BasicAI 공식 튜토리얼 (YouTube)
상세 인터페이스 및 데이터 업로드 문서: BasicAI 기술 문서 [1, 2, 3]

3. Encord (플랫폼 참고용)

실무에서 대규모 3D 포인트 클라우드 시퀀스를 다룰 때 유용한 상용 플랫폼 튜토리얼입니다. Fit cuboid to points(점군에 박스 밀착시키기)나 보간(Interpolation) 연산 조작법이 직관적으로 나와 있습니다.

3D Precision 라이다 가이드 영상: Encord 라이다 어노테이션 튜토리얼 (YouTube) [1]

영상에서 눈여겨보셔야 할 핵심 인터페이스 특징

영상을 재생해 보시면 소프트웨어 내부가 다음과 같이 구성되어 엔지니어가 조작하게 됩니다.

3D 자유 시점(Free Camera) 화면: 마우스 좌클릭(앵글 회전), 우클릭(카메라 축 이동)을 이용해 전체적인 점군 상태를 파악합니다.
3단 정사영 뷰(Top, Side, Front View): AI가 생성한 3D 박스를 위, 옆, 앞에서 직각으로 보며 물체 표면에 박스를 cm 단위로 밀착(Tightness) 시킬 때 마우스 드래그로 조작합니다.
카메라 뷰 연동: 라이다 점 위를 클릭하면 오른쪽에 동기화된 카메라 이미지가 나타나, 해당 물체가 차량인지 오토바이인지 시각적으로 교차 검증합니다. [1]

nelsknits 모헤어 보트 넥 탑 free pattern, 'mohair' boat neck top/off the shoulder top 무료도안 뜨개 몸에 맞게 뜨는 방법

sailorCat — Mon, 13 Apr 2026 17:53:08 +0900

https://www.instagram.com/nelsknits/

긴 팔

오프숄더

nelsknits 뜨개 작가의 인스타그램과 무료 도안 튜토리얼 유튜브 영상

오프숄더로 입을 수도 있고, 마지막 부분에 소매를 추가하면 반팔이나 긴팔로도 입을 수 있다.

너무 귀여운 디자인이다

신축성이 있고 얇은 모헤어로 만들기 때문에 간절기에 아우터와 입어도 되고 여름에 에어컨을 튼 실내에서도 입을 수 있을 것 같다.

초보자 용으로 적합한 뜨개이지만 주의할 점이 있다.

두 세 가지 정도 버전을 뜨면서 알게 된 팁

- 밝은 컬러의 모헤어를 사용할 때, 도안에서 늘림을 한 부분이 여기저기 흩어져 있어 완성하고 지저분해 보일 수 있기 때문에 양 끝에서만 늘림과 줄임을 하는 것을 추천

kfb 부분이 늘림인데 어두운 실로 뜨개를 하면 상관없지만 밝은 색 실은 여기저기서 늘림한 부분이 보이기 때문에

그냥 양 끝에 마커를 달아두고 every round 4번의 늘림을 하면 균일하게 늘어난다.

이런식으로 12*4 + 82 = 130

작가의 계산대로 하면 132가 된다.

자신의 사이즈보다 작다면 라운드를 추가해서 더 진행해도 될 것 같다.

어깨 부분

탑다운이기 때문에 소매 분리부분이 나타난다.

좌우대칭이기 때문에 내 팔 사이즈와 몸통 사이즈를 재서 나눌 수 있다.

양 끝에 마크를 해놨다면 분리하기 더 쉬울 것 같다.

소매분리

이후 몸통부분을 가슴 가장 윗부분까지 진행한다.

몸통-가슴까지

그 다음부터는 줄임이 시작된다.

두 개의 코를 잡고 한번에 뜨는 방식 k2tog로 19번의 줄임을 하는 것으로 되어 있다.

하지만 영상처럼 하면 밝은 실에서는 줄임을 한 부분이 여기저기 퍼져 있는게 보인다.

가슴부터 허리선이 밀착되는 핏이기 때문에 감소시켜야 하는데 이것도 양 끝에서만 진행하는 것을 추천한다.

총 27 라운드이기 때문에 3번째 라운드마다 양 끝에서 줄임을 하면 균일하게 18번의 줄임을 할 수 있다.

몸통-가슴 밑부분까지

가슴이 큰 편이라면 대각선으로 줄임이 생길 수 있으니 마커 위치를 등쪽으로 위치시키는 게 좋다.

마커를 위치하고, 등쪽이 아닌 가슴쪽으로 줄임을 진행하면 된다.

가슴 밑부분까지 줄임을 끝내면 5cm 허리 부분이 나올때까지 무한 겉뜨기 해주면 된다.

이후에 허리선 부분은 핏을 만들고 싶다면 아래의 추가 줄임을 진행하면 된다.

허리선 추가 줄임

cast off

보통 스웨터 뜨기 할때는 작은 바늘로 바꿔서 진행하지만 이 니트탑은 매우 몸에 밀착되는 디자인이기 때문에 오히려 바늘을 더 큰 것으로 바꾸어 엘라스틱한 캐스트 오프 방법을 사용해야 한다.

영상을 보면서 함께 뜨니까 좋았다.

어두운 색 실을 쓰면 영상처럼만 하면 되니까 고민할 필요도 없었고 체형도 비슷해서 사이즈를 변형할 필요가 없었다.

Imperfect Beginnings

sailorCat — Fri, 17 Oct 2025 05:14:29 +0900

It wasn't polished.

The floors creaked like old memories,

furniture leaned with stories,

corners held stories in dust,

and vacuum roared a trailing.

But I felt it

like slipping into vintage clothes

someone else had worn,

soft with memory, warm with time.

Ashwood didin't welcome me with grandeur,

but with softness,

with chipped edges and quiet light.

It was a beginning,

not flawless,

but mine.

다듬어지지 않은

바닥은 오랜 기억으로 삐걱이고,

사연 있는 가구는 기운,

오래된 이야기를 담은 먼지 쌓인 코너들과,

굉음을 내는 청소기가 있는

그럼에도

남이 입었던 옷 속으로

미끄러지듯 들어가는,

부드러운 기억과 따뜻한 시간들

화려하게 반겨주지 않았다.

조용하게,

깨진 모서리와 희미한 불빛으로.

시작,

완벽하지 않았지만,

내 것인.

From 888 to Ashwood

sailorCat — Fri, 17 Oct 2025 04:54:56 +0900

I stepped out of the loop of 888

and planted a forest on ashes.

Ashwood,

a place where flow and roots exist.

repetition has ceased,

a new world

begun within me.

나는 888의 고리를 벗어나

잿더미 위에 숲을 심었다.

애쉬우드,

흐름과 뿌리가 존재하는 곳

반복은 멈췄고

새로운 세계는

내 안에서 시작되었다.

사용자 시나리오를 통한 워크플로우 파이프라인 User Scenario workflow

sailorCat — Mon, 23 Jun 2025 21:35:58 +0900

사용자 시나리오

치수를 알고 싶은 물체 사진을 업로드 하고 한쪽 면에 대해 사이즈를 입력하면 전체 비율을 계산해서 정확한 치수를 높이, 너비, 길이, 지름 등등을 알려준다.

사용자가 반드시 하나의 치수를 입력해야 하고, 어떤 곳의 치수를 입력할 지는 고를 수 있다.

업로드한 사진의 물체를 분석해서 길이를 잴 수 있는 곳을 형광색 선으로 표시해서 선택할 수 있게 한다.

사용자가 그 중 하나를 클릭해서 치수를 입력하면 상대적 비율을 계산해서 전체 치수를 알려준다.

사진을 처음에 업로드 할 때 전체 치수의 상대비율을 알 수 없으면 다시 사진 업로드를 받는다.

1. Front-end Flow (User Scenario)

Image Upload • User drops or selects a photo of the object.
Auto-segmentation & Edge Proposal • System segments out the object silhouette and runs line/edge detection (e.g. Canny + Hough) to find all candidate “measurable” segments. • Highlight each candidate in translucent neon (e.g. fluorescent green).
User Picks One Reference Edge • User clicks the edge they actually measured with a ruler/caliper. • An inline form pops up asking: “Enter the real-world length of this segment (e.g. 85 mm)”.
Scale Calibration • Compute mm_per_pixel = user_length / pixel_length(ref_edge).
Dimension Extraction • Compute 2D bounding‐box or oriented bounding box on the mask ⇒ gives you pixel extents along its two principal axes. • Multiply by mm_per_pixel ⇒ returns two real‐world dims (e.g. width and height of that face). • Shape‐specific extras: – Rectangular box ⇒ # of faces = 3; we only got 2 from this view ⇒ need second view or second measurement to resolve depth. – Cylinder ⇒ silhouette minor axis = diameter (can compute directly).
Check Completeness • If all requested dims (width, height, depth, diameter…) are resolvable from this view + known shape ⇒ display them. • Otherwise prompt: “We still need a measurement of the 3rd axis (depth/length). Please upload a second photo showing that axis, or pick a different reference edge from your current photo.”
Final Report • Show a table: {width: xx mm, height: yy mm, depth: zz mm, diameter: dd mm} • Overlay result on the image/mesh for visual confirmation.

2. Back-end Pipeline

text

┌──────────────────┐
│ 1. Pre-processing│
├──────────────────┤
│ • Resize / normalize image              │
│ • Mask R-CNN / U^2-Net ⇒ object mask    │
│ • Perspective correction (vanishing-pt) │
│ • Canny → HoughLines → cluster by θ     │
│   → candidate edges                     │
└──────────────────┘
           ↓
┌──────────────────┐
│ 2. Edge Proposal │
├──────────────────┤
│ • Filter for longest / most “bold”      │
│ • Store: (p1,p2,pixel_length,θ,face_id) │
│ • Return segments to front-end UI       │
└──────────────────┘
           ↓
┌──────────────────┐
│ 3. User Input    │
├──────────────────┤
│ • ref_edge_id,   │
│ • real_length_mm │
└──────────────────┘
           ↓
┌──────────────────┐
│ 4. Scale Calib   │
├──────────────────┤
│ mm_per_px = real_length_mm / pixel_length(ref_edge) │
└──────────────────┘
           ↓
┌──────────────────┐
│ 5. Dim. Extract  │
├──────────────────┤
│ • Oriented BBox on mask ⇒ (w_px, h_px) │
│ • w_mm = w_px * mm_per_px             │
│ • h_mm = h_px * mm_per_px             │
│                                      │
│ • If shape=="cylinder":               │
│     diameter_mm = minor_axis_px * mm_per_px   │
└──────────────────┘
           ↓
┌──────────────────┐
│ 6. Completeness  │
├──────────────────┤
│ • If shape=="box" and we need depth:  │
│     depth unresolved ⇒ request 2nd view  │
│ • Else compile final dims             │
└──────────────────┘
           ↓
┌──────────────────┐
│ 7. Render & Resp │
├──────────────────┤
│ • Return JSON {w_mm, h_mm, d_mm?, dia_mm?} │
│ • Front-end overlays results on image     │
└──────────────────┘

3. Key Components & Why You Might Need a 2nd Photo

A single orthographic (fronto-parallel) shot of a box only gives you its two visible faces—third axis (depth) is foreshortened.
A cylinder you can get height + diameter from one view.
Perspective correction can help flatten but you still can’t conjure the hidden axis without another angle or a second measurement.

When you flip that “depth” flag, your UI should automatically re-prompt: “Depth not measured yet—please either measure a second edge on this photo OR upload a new image showing the object from the side.”

4. Next Steps

Prototype the edge-detection + UI overlay so users can click on any proposed line.
Wire up the scale calibration and oriented-bbox measurement.
Build the “need second view” logic—simple flag in your dimension‐output step.
Polish UX:
- show dynamic “mm_per_px” as they type
- allow switching reference edge if measure was imprecise
- cache previous uploads so second‐view is seamless

여기서 이미 메타데이터에 존재하는 오브젝트는 치수를 재고 비율을 계산하는 걸 거칠 필요 없이 바로 치수를 알려줄 수 있다.

Object Recognition & Retrieval • 사용자 업로드 이미지를 CNN(또는 이미지 임베딩 + FAISS) 기반으로 인덱스된 데이터셋에 매칭 • 예: “mug_001” → YCB 세트의 머그컵, “tube_30x50” → 30×50 mm 사각 튜브 등 • 매칭 신뢰도(confidence) 체크(예: > 0.9면 자동 처리)
Scale Check (선택) • 데이터셋 이미지는 보정된 픽셀→mm 정보를 갖고 있으므로, 보통 생략 가능 • 다만 실제 촬영 환경마다 해상도가 달라지므로, 필요하면 사용자에게 한 축 길이(예: 머그 컵 높이)를 입력받아 배율을 재보정
Dimension Lookup • 매칭된 객체의 JSON/CSV 메타데이터에서 width/depth/height, 지름(diameter) 등 필요한 모든 치수 항목을 읽어옴 • 예: { width:85, depth:80, height:95 }
사용자 피드백 • “이 물체가 mug_001(머그컵)이 맞습니까? → 예/아니오” • 아니오 선택 시, 일반 에지 기반 측정 플로우로 폴백(fallback)
최종 결과 리턴 • 바로 { width: 85 mm, depth: 80 mm, height: 95 mm } 형태로 UI에 표시 • 이미지 위에 주요 축에 해당하는 치수를 오버레이

딥러닝 기반 Depth 보조
- MiDaS, DPT 같은 단일 이미지 Depth 추정 네트워크를 얹고, 스케일 보정을 위해 사용자가 입력한 참조 길이(혹은 ArUco 마커)로 전체 깊이 맵을 Real-World 스케일로 변환
- 그렇게 얻은 3D 포인트클라우드를 통해 눈에 보이지 않는 면의 깊이도 어느 정도 예측 가능
물체 카테고리별 Shape Prior 활용
- 컵, 책상, 의자 등 범용 카테고리별로 “기본 형태(프리미티브, CAD 템플릿)”를 미리 정의
- 사진 위 실루엣이나 엣지에 프리미티브를 매칭(fitting)해서 스케일과 평행이동, 회전 파라미터를 최적화
- 이런 방식으로 보이지 않는 면까지 그 “템플릿”의 실제 치수를 불러올 수 있음
Photometric Stereo / Shape-from-Shading
- 하나의 이미지라도 간단히 플래시 온·오프 두 장 정도만 찍으면, 조명 변화에 따른 밝기 차이로 물체 표면 노멀 벡터(곡률) 추정
- 노멀 지도에서 기하학적 형태를 재구성해 엣지가 없는 곡면 물체(구, 실린더 등)의 치수를 예측
EXIF·메타데이터 활용
- 사진 EXIF에서 화각(FOV), 초점 거리, 센서 크기 정보를 꺼내면, 픽셀→실제 거리 환산에 필요한 내부 파라미터 일부를 자동으로 유추 가능
- 사용자에게 “스마트폰 기종”이나 “초점 거리(mm)” 정도만 물어봐도 캘리브레이션 부담을 줄일 수 있음
사용자 인터랙션 강화
- “2점 클릭” 대신 “면 클릭 + 드래그” UI: 사용자가 대략적인 면(사각형/원)을 드래그하면, 그 영역 크기를 픽셀 단위로 알아서 측정
- 측정 선분 후보를 자동으로 군집화(cluster) → 대표성 높은 3~5개만 추려서 보여주기 → 사용자가 선택
멀티 뷰 영상 보조
- 사진 한 장으론 충분치 않으니, 간단히 사용자에게 3초짜리 짧은 비디오(360° 회전) 촬영을 권유
- SLAM(ORB-SLAM 등)으로 카메라 트랙 추정 → 비디오 프레임에서 물체 지점들까지의 거리 정보로 정확한 3D 포인트 클라우드 재구성
문맥·사전 지식 연계
- 물체에 찍힌 브랜드 로고나 텍스트를 OCR로 읽고, 해당 모델명·스펙 정보를 크롤링해서 치수를 메타데이터로 바로 매핑
- 예: “IKEA” 로고 → “IKEA POÄNG” → 웹에서 사이즈 스펙 자동 조회
품질 평가 & 재촬영 권유
- 자동으로 “측정 신뢰도”(photometric condition, 엣지 밀도, 원근 왜곡량 등)를 계산해, 특정 임계치 이하일 땐 “다시 찍어주세요” 안내
- 촬영 가이드 오버레이(화면 구석에 마커 붙이기, 일정 거리 유지하기) 제공
모바일 SDK/ARKit 연동
- iOS ARKit, Android ARCore Measure API를 백엔드로 호출해서, 단순한 물체 치수 측정은 기기 내장 기능으로 처리
- 앱 내에서 “더 정밀한 측정이 필요하면 서버 파이프라인”으로 폴백
최종 설정 자동화 파라미터

파이프라인마다 중요한 파라미터(e.g. Canny threshold, Hough minimum line length)들을 AutoML로 튜닝하거나, 사용자 기종·환경별 프리셋 제공

가장 실현 속도가 빠른 건 EXIF 활용 + ArUco 마커 스케일, • 정확도를 더 끌어올리고 싶다면 Shape Prior + Depth Estimation, • 사용자 경험을 챙기려면 모바일 ARKit/ARCore 연동과 품질 피드백 기능

사진

sailorCat — Sat, 21 Jun 2025 22:06:23 +0900

FastAPI with ***** ? Softwares and Servers use with FastAPI

sailorCat — Sat, 21 Jun 2025 12:46:04 +0900

FastAPI with ***** ?

softwares that are usally use with FastAPI

FastAPI is a versatile framework that can be integrated with various software and tools to enhance its functionality. Here are some popular ones:

Databases

SQLAlchemy: An ORM (Object-Relational Mapper) for working with SQL databases.
Tortoise-ORM: Another ORM that supports asynchronous operations.
MongoDB: A NoSQL database that can be used with FastAPI through libraries like Motor.

Authentication

OAuth2: FastAPI has built-in support for OAuth2, which is commonly used for authentication.
JWT (JSON Web Tokens): Libraries like PyJWT can be used for token-based authentication.

Frontend Frameworks

React: A popular JavaScript library for building user interfaces.
Vue.js: Another JavaScript framework for building UIs.
Angular: A TypeScript-based framework for building web applications.

Deployment

Docker: Containerization platform to package and deploy FastAPI applications.
Kubernetes: Orchestration tool for managing containerized applications.
Heroku: A cloud platform that supports FastAPI deployment.

Testing

Pytest: A testing framework for writing and running tests.
HTTPX: An HTTP client for making requests during testing.

Documentation

Swagger UI: Automatically generated interactive API documentation.
ReDoc: Another tool for generating API documentation.

Other Tools

Celery: A task queue for handling background tasks.
Redis: An in-memory data structure store, often used as a cache or message broker.

Servers that are using with FastAPI

Common Server Environments for FastAPI

Uvicorn: An ASGI server that is commonly used to run FastAPI applications. It's lightweight and efficient.
Daphne: Another ASGI server that can be used with FastAPI, often chosen for its support of WebSocket protocols.
Gunicorn: A WSGI server that can be used with FastAPI applications by running them through Uvicorn workers.
Nginx: Often used as a reverse proxy server to handle incoming HTTP requests and forward them to the FastAPI application running on an ASGI server like Uvicorn.
Docker: As mentioned earlier, Docker can be used to containerize FastAPI applications for easier deployment and scaling on various cloud platforms.

Deployment Platforms

AWS (Amazon Web Services): FastAPI applications can be deployed using services like EC2 (Elastic Compute Cloud) or ECS (Elastic Container Service) with Docker.
Google Cloud Platform: You can use Google App Engine, Google Kubernetes Engine, or Compute Engine to deploy FastAPI applications.
Microsoft Azure: Azure App Service, Azure Kubernetes Service, and Azure Virtual Machines are common choices for deploying FastAPI applications.
Heroku: A user-friendly platform for deploying applications, including FastAPI, with minimal configuration.

To adjust docker and Uvicorn to code

app/main.py

from fastapi import FastAPI
from app.routes import predict, train, update, hyperparameter_tuning
from app.utils.error_handler import custom_error_handler
from fastapi.exceptions import RequestValidationError

app = FastAPI()

# Include the routers from different endpoints
app.include_router(predict.router)
app.include_router(train.router)
app.include_router(update.router)
app.include_router(hyperparameter_tuning.router)

# Add error handler
app.add_exception_handler(RequestValidationError, custom_error_handler)
app.add_exception_handler(Exception, custom_error_handler)

# The following lines are added to run the app with Uvicorn
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Location of the Dockerfile

Add Authentication

At first I tried the put OAuth2 function with 2FA(two step authentication). The container has not been changed.

app/main.py

from fastapi import FastAPI, Depends, HTTPException, Request
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from jose import JWTError, jwt
from passlib.context import CryptContext
from pydantic import BaseModel
from datetime import datetime, timedelta
import random
import string

app = FastAPI()

# Secret key to encode the JWT
SECRET_KEY = "your_secret_key"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

# Password hashing context
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

# OAuth2 scheme
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

# In-memory store for 2FA codes
two_factor_auth_codes = {}

# Fake user database
fake_users_db = {
    "user@example.com": {
        "username": "user@example.com",
        "hashed_password": pwd_context.hash("password"),
    }
}

class Token(BaseModel):
    access_token: str
    token_type: str

class TokenData(BaseModel):
    username: str | None = None

class User(BaseModel):
    username: str

class UserInDB(User):
    hashed_password: str

class TwoFactorData(BaseModel):
    username: str
    code: str

def verify_password(plain_password, hashed_password):
    return pwd_context.verify(plain_password, hashed_password)

def get_user(db, username: str):
    if username in db:
        user_dict = db[username]
        return UserInDB(**user_dict)

def authenticate_user(fake_db, username: str, password: str):
    user = get_user(fake_db, username)
    if not user:
        return False
    if not verify_password(password, user.hashed_password):
        return False
    return user

def create_access_token(data: dict, expires_delta: timedelta | None = None):
    to_encode = data.copy()
    if expires_delta:
        expire = datetime.utcnow() + expires_delta
    else:
        expire = datetime.utcnow() + timedelta(minutes=15)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

def generate_2fa_code():
    return ''.join(random.choices(string.digits, k=6))

def send_2fa_code(username: str, code: str):
    # In a real application, send the code via SMS, email, or an authenticator app
    print(f"2FA code for {username}: {code}")

@app.post("/token", response_model=Token)
async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
    user = authenticate_user(fake_users_db, form_data.username, form_data.password)
    if not user:
        raise HTTPException(
            status_code=400,
            detail="Incorrect username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    code = generate_2fa_code()
    two_factor_auth_codes[form_data.username] = code
    send_2fa_code(form_data.username, code)
    return {"access_token": "2fa_required", "token_type": "bearer"}

@app.post("/2fa", response_model=Token)
async def verify_2fa_code(data: TwoFactorData):
    if data.username in two_factor_auth_codes and two_factor_auth_codes[data.username] == data.code:
        access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
        access_token = create_access_token(
            data={"sub": data.username}, expires_delta=access_token_expires
        )
        del two_factor_auth_codes[data.username]  # Remove used code
        return {"access_token": access_token, "token_type": "bearer"}
    else:
        raise HTTPException(
            status_code=400,
            detail="Invalid 2FA code",
            headers={"WWW-Authenticate": "Bearer"},
        )

@app.get("/users/me", response_model=User)
async def read_users_me(current_user: User = Depends(get_current_user)):
    return current_user

async def get_current_user(token: str = Depends(oauth2_scheme)):
    credentials_exception = HTTPException(
        status_code=401,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username: str = payload.get("sub")
        if username is None:
            raise credentials_exception
        token_data = TokenData(username=username)
    except JWTError:
        raise credentials_exception
    user = get_user(fake_users_db, username=token_data.username)
    if user is None:
        raise credentials_exception
    return user

# Include the routers from different endpoints
from app.routes import predict, train, update, hyperparameter_tuning
app.include_router(predict.router)
app.include_router(train.router)
app.include_router(update.router)
app.include_router(hyperparameter_tuning.router)

# Add error handler
from app.utils.error_handler import custom_error_handler
from fastapi.exceptions import RequestValidationError
app.add_exception_handler(RequestValidationError, custom_error_handler)
app.add_exception_handler(Exception, custom_error_handler)

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)  # This line is added

app/utils/error_handler.py

from fastapi.responses import JSONResponse
from fastapi import Request

async def custom_error_handler(request: Request, exc):
    return JSONResponse(
        status_code=400,
        content={"message": f"Oops! Something went wrong: {str(exc)}"}
    )

app/utils/transformers_utils.py

from transformers import ElectraTokenizer, ElectraForSequenceClassification, Trainer, TrainingArguments
import torch
from datasets import load_metric, Dataset
import optuna

class TransformersModel:
    def __init__(self, model_name: str):
        self.tokenizer = ElectraTokenizer.from_pretrained(model_name)
        self.model = ElectraForSequenceClassification.from_pretrained(model_name)
        self.metric = load_metric("accuracy")

    def predict(self, text: str):
        inputs = self.tokenizer(text, return_tensors='pt')
        outputs = self.model(**inputs)
        logits = outputs.logits
        probabilities = torch.nn.functional.softmax(logits, dim=-1)
        predicted_class = torch.argmax(probabilities, dim=1).item()
        return {"class": predicted_class, "probabilities": probabilities.tolist()}

    def train(self, train_dataset: Dataset, eval_dataset: Dataset, output_dir: str, training_args: dict):
        args = TrainingArguments(
            output_dir=output_dir,
            num_train_epochs=training_args["num_train_epochs"],
            per_device_train_batch_size=training_args["per_device_train_batch_size"],
            per_device_eval_batch_size=training_args["per_device_eval_batch_size"],
            evaluation_strategy="steps",
            save_steps=10_000,
            eval_steps=500,
            logging_dir=f"{output_dir}/logs",
            learning_rate=training_args["learning_rate"],
            weight_decay=training_args["weight_decay"],
        )
        trainer = Trainer(
            model=self.model,
            args=args,
            train_dataset=train_dataset,
            eval_dataset=eval_dataset,
            tokenizer=self.tokenizer,
            compute_metrics=self.compute_metrics,
        )
        trainer.train()
        trainer.save_model(output_dir)
        return {"status": "Training completed"}

    def update(self, new_train_texts: list, new_train_labels: list, output_dir: str):
        new_train_dataset = Dataset.from_dict({"text": new_train_texts, "label": new_train_labels})
        return self.train(new_train_dataset, new_train_dataset, output_dir, self.default_training_args())
    
    def hyperparameter_tuning(self, train_dataset: Dataset, eval_dataset: Dataset, output_dir: str):
        def objective(trial):
            training_args = {
                "num_train_epochs": trial.suggest_int("num_train_epochs", 1, 5),
                "per_device_train_batch_size": trial.suggest_categorical("per_device_train_batch_size", [8, 16, 32]),
                "per_device_eval_batch_size": trial.suggest_categorical("per_device_eval_batch_size", [8, 16, 32]),
                "learning_rate": trial.suggest_loguniform("learning_rate", 1e-5, 1

How to measure the app?

When I use the computer or app. If It is slow I don’t use it. So I know how much important the app speed is.

Let’s check it with Copilot!

The speed of your application might be impacted by the added complexity and features, but there are several strategies you can use to maintain or even improve performance:

Optimization Tips

Asynchronous Operations: Ensure that you're making use of FastAPI's asynchronous capabilities (e.g., async/await) to handle I/O-bound tasks like database queries and external API calls efficiently.
Efficient Data Processing: Optimize your data processing pipelines to reduce bottlenecks. Use efficient data structures and algorithms, and consider batch processing if applicable.
Caching: Implement caching for frequently accessed data or computationally expensive operations. Tools like Redis can be used for caching.
Database Optimization: Ensure that your database queries are optimized. Use indexing, pagination, and avoid unnecessary queries.
Load Balancing: Distribute the load across multiple instances of your application using load balancers to improve scalability and performance.
Profiling and Monitoring: Use profiling tools to identify performance bottlenecks and optimize them. Tools like Prometheus and Grafana can help with monitoring performance metrics.
Hardware Resources: Ensure that the server or infrastructure you're using has sufficient hardware resources (CPU, memory, etc.) to handle the increased load.

Assessing Performance

To measure the performance impact of your changes, you can use benchmarking and monitoring tools:

Benchmarking Tools: Use tools like ab (Apache Bench), wrk, or locust to simulate load on your application and measure response times and throughput.
Profiling Tools: Use profiling tools like cProfile, py-spy, or perf to identify performance bottlenecks in your code.
Monitoring Tools: Use monitoring tools like Prometheus, Grafana, or New Relic to track performance metrics in real time.

Thank you for reading! xoxo

내가 노션에 정리한 내용을 블로그로 다시 옮겨왔다.

https://snow-light-ac7.notion.site/FastAPI-1989a232cc3580fb9c25ee5693abf945#19d9a232cc3580d0a54cf27ff2ba7615

FastAPI | Notion

This is summary of what I learned about FastAPI!

snow-light-ac7.notion.site

Let's build a Rest API using FastAPI and Copliot!

sailorCat — Sat, 21 Jun 2025 12:41:18 +0900

Let's build a REST API using FastAPI, Copilot!

https://github.com/Hippy-Happy/DassuL

GitHub - Hippy-Happy/DassuL

Contribute to Hippy-Happy/DassuL development by creating an account on GitHub.

github.com

I’m gonna use this code for bulid the api today.

To simply explain this document, It was the NLP project from Korea which can detect hatespeech or discrimination word.

I already made the code with Flask API. But today we’ll try another option FastAPI with Copilot!!

And one thing I wanna explain about this whole situation, using copilot instead of doing it myself, is that I was unable to install development software tools with Melbourne free Library computers at that moment..

Try 1

I applied this sentence to Copilot and then it works.

and basic codes etc… It’s not the code I wanted. so let’s try again.

Try 2

Downloaded the raw file of training sheets and then directly give it to Copilot.

And then It was impossible for using downloaded files with Library computers….

Try 3

I gave the file name in the github to Copilot, and then it works.

This is the code.

main.py

from fastapi import FastAPI
from routers import transformers

app = FastAPI()

app.include_router(transformers.router)

@app.get("/")
def read_root():
    return {"Hello": "World"}

routers/transformers.py

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from typing import List

from models import transformers
from schemas import transformers as transformers_schema
from crud import transformers as transformers_crud
from database import get_db

router = APIRouter()

@router.get("/transformers", response_model=List[transformers_schema.Transformer])
def read_transformers(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
    transformers = transformers_crud.get_transformers(db, skip=skip, limit=limit)
    return transformers

@router.post("/transformers", response_model=transformers_schema.Transformer)
def create_transformer(transformer: transformers_schema.TransformerCreate, db: Session = Depends(get_db)):
    return transformers_crud.create_transformer(db=db, transformer=transformer)

models/transformers.py

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from typing import List

from models import transformers
from schemas import transformers as transformers_schema
from crud import transformers as transformers_crud
from database import get_db

router = APIRouter()

@router.get("/transformers", response_model=List[transformers_schema.Transformer])
def read_transformers(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
    transformers = transformers_crud.get_transformers(db, skip=skip, limit=limit)
    return transformers

@router.post("/transformers", response_model=transformers_schema.Transformer)
def create_transformer(transformer: transformers_schema.TransformerCreate, db: Session = Depends(get_db)):
    return transformers_crud.create_transformer(db=db, transformer=transformer)

schemas/transformers.py

from pydantic import BaseModel

class TransformerBase(BaseModel):
    name: str
    accuracy: float
    model_path: str

class TransformerCreate(TransformerBase):
    pass

class Transformer(TransformerBase):
    id: int

    class Config:
        orm_mode = True

crud/transformers.py

from pydantic import BaseModel

class TransformerBase(BaseModel):
    name: str
    accuracy: float
    model_path: str

class TransformerCreate(TransformerBase):
    pass

class Transformer(TransformerBase):
    id: int

    class Config:
        orm_mode = True

services/transformers.py

# Add any service logic or utility functions related to your transformers here

def train_transformer(model_path: str):
    # Your training logic from the notebook goes here
    pass

def evaluate_transformer(model_path: str):
    # Your evaluation logic from the notebook goes here
    pass

database.py

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"

engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

And then Copilot suggested me these questions about the code.

basically what I needed in this code for using this API practically.

first I questioned of dependencies.

Then I wanted to add the error function into the code.

So many files pop up at this part, I questioned it again.

Added http_exception_handler and custom_exception_handler for handling exceptions.

main.py

from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import JSONResponse
from routers import transformers

app = FastAPI()

app.include_router(transformers.router)

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
    return JSONResponse(
        status_code=exc.status_code,
        content={"message": exc.detail},
    )

class CustomException(Exception):
    def __init__(self, name: str):
        self.name = name

@app.exception_handler(CustomException)
async def custom_exception_handler(request: Request, exc: CustomException):
    return JSONResponse(
        status_code=400,
        content={"message": f"Oops! Something went wrong with {exc.name}."},
    )

Added conditions to raise CustomException and HTTPException.

routers/transformers.py

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from typing import List

from models import transformers
from schemas import transformers as transformers_schema
from crud import transformers as transformers_crud
from database import get_db
+ from main import CustomException

router = APIRouter()

@router.get("/transformers", response_model=List[transformers_schema.Transformer])
def read_transformers(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
+    if limit > 100:
+        raise CustomException(name="Transformer List Limit")
    transformers = transformers_crud.get_transformers(db, skip=skip, limit=limit)
+    if not transformers:
+        raise HTTPException(status_code=404, detail="Transformers not found")
    return transformers

@router.post("/transformers", response_model=transformers_schema.Transformer)
def create_transformer(transformer: transformers_schema.TransformerCreate, db: Session = Depends(get_db)):
+    if not transformer.name:
+        raise CustomException(name="Transformer Name")
    return transformers_crud.create_transformer(db=db, transformer=transformer)

Try 4

app/main.py

from fastapi import FastAPI
from app.routes import predict, train, update, hyperparameter_tuning
from app.utils.error_handler import custom_error_handler
from fastapi.exceptions import RequestValidationError

app = FastAPI()

# Include the routers from different endpoints
app.include_router(predict.router)
app.include_router(train.router)
app.include_router(update.router)
app.include_router(hyperparameter_tuning.router)

# Add error handler
app.add_exception_handler(RequestValidationError, custom_error_handler)
app.add_exception_handler(Exception, custom_error_handler)

app/utils/error_handler.py

from fastapi.responses import JSONResponse
from fastapi import Request

async def custom_error_handler(request: Request, exc):
    return JSONResponse(
        status_code=400,
        content={"message": f"Oops! Something went wrong: {str(exc)}"}
    )

app/utils/transformers_utils.py

from transformers import ElectraTokenizer, ElectraForSequenceClassification, Trainer, TrainingArguments
import torch
from datasets import load_metric, Dataset
import optuna

class TransformersModel:
    def __init__(self, model_name: str):
        self.tokenizer = ElectraTokenizer.from_pretrained(model_name)
        self.model = ElectraForSequenceClassification.from_pretrained(model_name)
        self.metric = load_metric("accuracy")

    def predict(self, text: str):
        inputs = self.tokenizer(text, return_tensors='pt')
        outputs = self.model(**inputs)
        logits = outputs.logits
        probabilities = torch.nn.functional.softmax(logits, dim=-1)
        predicted_class = torch.argmax(probabilities, dim=1).item()
        return {"class": predicted_class, "probabilities": probabilities.tolist()}

    def train(self, train_dataset: Dataset, eval_dataset: Dataset, output_dir: str, training_args: dict):
        args = TrainingArguments(
            output_dir=output_dir,
            num_train_epochs=training_args["num_train_epochs"],
            per_device_train_batch_size=training_args["per_device_train_batch_size"],
            per_device_eval_batch_size=training_args["per_device_eval_batch_size"],
            evaluation_strategy="steps",
            save_steps=10_000,
            eval_steps=500,
            logging_dir=f"{output_dir}/logs",
            learning_rate=training_args["learning_rate"],
            weight_decay=training_args["weight_decay"],
        )
        trainer = Trainer(
            model=self.model,
            args=args,
            train_dataset=train_dataset,
            eval_dataset=eval_dataset,
            tokenizer=self.tokenizer,
            compute_metrics=self.compute_metrics,
        )
        trainer.train()
        trainer.save_model(output_dir)
        return {"status": "Training completed"}

    def update(self, new_train_texts: list, new_train_labels: list, output_dir: str):
        new_train_dataset = Dataset.from_dict({"text": new_train_texts, "label": new_train_labels})
        return self.train(new_train_dataset, new_train_dataset, output_dir, self.default_training_args())
    
    def hyperparameter_tuning(self, train_dataset: Dataset, eval_dataset: Dataset, output_dir: str):
        def objective(trial):
            training_args = {
                "num_train_epochs": trial.suggest_int("num_train_epochs", 1, 5),
                "per_device_train_batch_size": trial.suggest_categorical("per_device_train_batch_size", [8, 16, 32]),
                "per_device_eval_batch_size": trial.suggest_categorical("per_device_eval_batch_size", [8, 16, 32]),
                "learning_rate": trial.suggest_loguniform("learning_rate", 1e-5, 1e-4),
                "weight_decay": trial.suggest_loguniform("weight_decay", 1e-4, 1e-2),
            }
            result = self.train(train_dataset, eval_dataset, output_dir, training_args)
            accuracy = result["accuracy"]
            return accuracy
        
        study = optuna.create_study(direction="maximize")
        study.optimize(objective, n_trials=20)
        return study.best_params
    
    def compute_metrics(self, p):
        preds = torch.argmax(p.predictions, dim=1)
        return self.metric.compute(predictions=preds, references=p.label_ids)

    def default_training_args(self):
        return {
            "num_train_epochs": 3,
            "per_device_train_batch_size": 8,
            "per_device_eval_batch_size": 8,
            "learning_rate": 2e-5,
            "weight_decay": 0.01,
        }

app/routes/predict.py

from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from app.utils.transformers_utils import TransformersModel

router = APIRouter()

# Initialize the transformers model with Electra
model = TransformersModel(model_name='monologg/koelectra-base-v3-discriminator')

class TextData(BaseModel):
    text: str

@router.post("/predict")
async def predict(text_data: TextData):
    try:
        prediction = model.predict(text_data.text)
        return prediction
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

app/routes/train.py

from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from app.utils.transformers_utils import TransformersModel
from datasets import Dataset

router = APIRouter()

# Initialize the transformers model (replace 'model_name' with your model)
model = TransformersModel(model_name='monologg/koelectra-base-v3-discriminator')

class TrainData(BaseModel):
    train_texts: list
    train_labels: list
    eval_texts: list
    eval_labels: list
    output_dir: str

@router.post("/train")
async def train_model(train_data: TrainData):
    try:
        train_dataset = Dataset.from_dict({"text": train_data.train_texts, "label": train_data.train_labels})
        eval_dataset = Dataset.from_dict({"text": train_data.eval_texts, "label": train_data.eval_labels})
        
        result = model.train(train_dataset, eval_dataset, train_data.output_dir, model.default_training_args())
        return result
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

app/routes/updates.py

from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from app.utils.transformers_utils import TransformersModel

router = APIRouter()

# Initialize the transformers model (replace 'model_name' with your model)
model = TransformersModel(model_name='monologg/koelectra-base-v3-discriminator')

class UpdateData(BaseModel):
    new_train_texts: list
    new_train_labels: list
    output_dir: str

@router.post("/update")
async def update_model(update_data: UpdateData):
    try:
        result = model.update(update_data.new_train_texts, update_data.new_train_labels, update_data.output_dir)
        return result
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

app/routes/hyperparameter_tuning.py

from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from app.utils.transformers_utils import TransformersModel
from datasets import Dataset

router = APIRouter()

# Initialize the transformers model with Electra
model = TransformersModel(model_name='monologg/koelectra-base-v3-discriminator')

class HyperparameterData(BaseModel):
    train_texts: list
    train_labels: list
    eval_texts: list
    eval_labels: list
    output_dir: str

@router.post("/hyperparameter_tuning")
async def hyperparameter_tuning(hyperparameter_data: HyperparameterData):
    try:
        train_dataset = Dataset.from_dict({"text": hyperparameter_data.train_texts, "label": hyperparameter_data.train_labels})
        eval_dataset = Dataset.from_dict({"text": hyperparameter_data.eval_texts, "label": hyperparameter_data.eval_labels})
        
        best_params = model.hyperparameter_tuning(train_dataset, eval_dataset, hyperparameter_data.output_dir)
        return {"best_params": best_params}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

I asked Copilot about the latest paper to approve it.

I asked the Copilot, With consideration of response speed of my api which paper is most suitable. And show me the result.

Considering the need to balance response speed with high performance in your FastAPI application, one of the most suitable advancements could be from the paper on RAG Foundry: Enhancing LLMs for Retrieval Augmented Generation.

Why RAG Foundry is Suitable:

Efficient Retrieval-Augmented Generation: RAG Foundry integrates retrieval mechanisms to augment the generation process. This can help in providing faster, contextually accurate responses by retrieving relevant information efficiently.
Asynchronous Retrieval: The paper's methodologies can be adapted to use asynchronous processing, which FastAPI supports natively. This ensures non-blocking operations, leading to faster response times.
Reduced Computational Load: By leveraging pre-retrieved relevant information, the model can generate responses with less computational overhead compared to processing everything from scratch.
Optimized for Real-Time Applications: The techniques are designed to enhance real-time applications, making them ideal for APIs that require quick turnaround times.

Practical Integration

Here's how you might apply the principles from RAG Foundry to your existing FastAPI application:

Implement a Retriever for Augmenting Responses: Use a retriever to gather relevant data quickly.
Asynchronous Endpoints: Ensure all endpoints are asynchronous to handle concurrent requests efficiently.
Optimize Model Inference: Use optimized inference libraries or frameworks (e.g., ONNX Runtime) to speed up model predictions.

app/utils/transformers_utils.py

from transformers import RagTokenizer, RagRetriever, RAGForSequenceClassification
import torch
from datasets import load_metric, Dataset
import optuna

class TransformersModel:
    def __init__(self, model_name: str):
        self.tokenizer = RagTokenizer.from_pretrained(model_name)
        self.retriever = RagRetriever.from_pretrained(model_name)
        self.model = RAGForSequenceClassification.from_pretrained(model_name)
        self.metric = load_metric("accuracy")

    async def predict(self, text: str):
        inputs = self.tokenizer(text, return_tensors='pt')
        retrieved_docs = await self.retriever(inputs.input_ids)
        inputs['retrieved_docs'] = retrieved_docs
        outputs = self.model(**inputs)
        logits = outputs.logits
        probabilities = torch.nn.functional.softmax(logits, dim=-1)
        predicted_class = torch.argmax(probabilities, dim=1).item()
        return {"class": predicted_class, "probabilities": probabilities.tolist()}

    async def train(self, train_dataset: Dataset, eval_dataset: Dataset, output_dir: str, training_args: dict):
        args = TrainingArguments(
            output_dir=output_dir,
            num_train_epochs=training_args["num_train_epochs"],
            per_device_train_batch_size=training_args["per_device_train_batch_size"],
            per_device_eval_batch_size=training_args["per_device_eval_batch_size"],
            evaluation_strategy="steps",
            save_steps=10_000,
            eval_steps=500,
            logging_dir=f"{output_dir}/logs",
            learning_rate=training_args["learning_rate"],
            weight_decay=training_args["weight_decay"],
        )
        trainer = Trainer(
            model=self.model,
            args=args,
            train_dataset=train_dataset,
            eval_dataset=eval_dataset,
            tokenizer=self.tokenizer,
            compute_metrics=self.compute_metrics,
        )
        await trainer.train()
        trainer.save_model(output_dir)
        return {"status": "Training completed"

    def update(self, new_train_texts: list, new_train_labels: list, output_dir: str):
        new_train_dataset = Dataset.from_dict({"text": new_train_texts, "label": new_train_labels})
        return self.train(new_train_dataset, new_train_dataset, output_dir, self.default_training_args())

    def hyperparameter_tuning(self, train_dataset: Dataset, eval_dataset: Dataset, output_dir: str):
        def objective(trial):
            training_args = {
                "num_train_epochs": trial.suggest_int("num_train_epochs", 1, 5),
                "per_device_train_batch_size": trial.suggest_categorical("per_device_train_batch_size", [8, 16, 32]),
                "per_device_eval_batch_size": trial.suggest_categorical("per_device_eval_batch_size", [8, 16, 32]),
                "learning_rate": trial.suggest_loguniform("learning_rate", 1e-5, 1e-4),
                "weight_decay": trial.suggest_loguniform("weight_decay", 1e-4, 1e-2),
            }
            result = self.train(train_dataset, eval_dataset, output_dir, training_args)
            accuracy = result["accuracy"]
            return accuracy
        
        study = optuna.create_study(direction="maximize")
        study.optimize(objective, n_trials=20)
        return study.best_params

    def compute_metrics(self, p):
        preds = torch.argmax(p.predictions, dim=1)
        return self.metric.compute(predictions=preds, references=p.label_ids)

    def default_training_args(self):
        return {
            "num_train_epochs": 3,
            "per_device_train_batch_size": 8,
            "per_device_eval_batch_size": 8,
            "learning_rate": 2e-5,
            "weight_decay": 0.01,
        }

app/routes/predict.py

from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from app.utils.transformers_utils import TransformersModel

router = APIRouter()

# Initialize the transformers model with RAG
model = TransformersModel(model_name='facebook/rag-token-nq')

class TextData(BaseModel):
    text: str

@router.post("/predict")
async def predict(text_data: TextData):
    try:
        prediction = await model.predict(text_data.text)
        return prediction
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))