미니감자

[UNLV] Las Vegas에서 한 달 여행기 - 하편

빡성 — Tue, 10 Mar 2026 16:49:39 +0900

Travel Journal · 2편

그랜드캐니언부터 인천 귀국까지

2025.02.14 ~ 03.02 South Outlet → Valley of Fire → Bryce/Antelope/Grand Canyon → Incheon

South Outlet & LV Strip 2/14 ~ 2/15

South Outlet에 있는 한식집

2월 14일과 15일은 두번째 주말이었습니다. 14일에는 North Outlet에 이어 South Outlet을 갔습니다. 아울렛 쇼핑은 돈을 많이 써서 그런지 역시 재밌더라구요ㅎ 그리고 이 날 되게 유명하신 한국 여배우를 Levis매장에서 뵀는데 지인들과 있어서 말은 못걸었지만.. 실물이 장난 아니었습니다

그리고 점심으로 아울렛에 있는 한식집을 갔는데 사장님이 한국분이어서 주문도 편했고 음식도 고향의 맛을.. 맛보게 된 행복한 시간이었습니다.

Strip에 있는 코카콜라 스토어

15일에는 LV Strip에 갔습니다. 코카콜라 스토어랑 M&M 스토어도 가고, 롤러코스터도 탔습니다!! 스트립에 있는 롤러코스터 진짜 재밌었어요.(2번 탄건 안비밀) 그리고 유명하다는 와더버거도 먹었는데 감튀랑 같이 찍어먹는 밀크쉐이크가 한국와서도 계속 생각 날 정도로 맛있었습니다...

Valley of Fire 2/16

valley of fire에서 찍은 사진ㅎ

2월 16일에는 Presidents' day라서 쉬는 날이라 Valley of Fire에 갔습니다. 붉은 바위와 사막 풍경이 정말 웅장했습니다. 사진 찍기 좋은 곳이 많아서 여기저기 담았던 기억이 나네요. 배경들이 어딜 찍든 이쁘게 다 나와서 나중에 갈 캐니언 트립이 더 기대 되었습니다 ㅎ

Buddy Program & Town Square 2/17 ~ 2/20

또 다시 한식ㅎ

수업은 계속 이어졌고, 2월 18일에는 저녁에 Buddy Program으로 Town Square에 갔습니다. 외국인 친구와 같이 한식도 먹고 쇼핑도 했습니다. 현지 학생들이랑 어울리면서 대화하는 시간이 좋았어요. 이때 나름(?) 영어 회화실력도 향상된 것 같아서 좋았습니다! 이때는 정신이 없어서 먹는것 밖에 못찍었네요..

⭐ 가장 기대되었던 활동!! ⭐️

Bryce Canyon & Horseshoe Bend & Antelope Canyon & Grand Canyon 2/21 ~ 2/22

2월 21일에는 Bryce Canyon이랑 Horseshoe Bend를 갔습니다.

Bryce Canyon 풍경(정상에서 찍은 사진)

눈이 너무 많이 왔어요...

Bryce Canyon은 오렌지색 기암괴석이 매우 인상 깊었습니다. 문제는.. 최근에 폭설이 왔다고 해서 눈이 많이 쌓여있어서 등산하는 과정이 매우매우 힘들었습니다. 미끄럽고 옷도 다 젖어서 힘들긴 했지만 주변을 둘러볼때마다 '우와' 소리가 절로 나올 정도로 이쁜 풍경이 펼쳐져있었습니다.

멀리서 보면 말발굽 닮았습니다 정말

Horseshoe Bend는 바로 앞까지 가서 구경해보니 말발굽 모양 강이 정말정말 인상적이었습니다. 근데 여기서 팬스가 없는 부분이 있는데 그런 부분에서 사진을 찍고 싶었지만 차마 무서워서 찍지 못해서 아쉬웠습니다ㅜ

2월 22일에는 앤텔로프 캐니언이랑 대망의 그랜드 캐니언을 갔습니다!!

가이드분이 찍어주신 사진(독수리..? 닮았다고 하심)

앤텔로프 캐니언은 나바호 족에게 직접 가이드를 받으며 구경했는데 빛이 비치는 계곡 풍경이 너무 예뻤고, 중간중간 암석이 닮은 것들을 포인트로 설명해주고 사진도 찍어주셔서 정말 투어에 온 기분이 들었습니다.

기대하고 기대하던 Grand Canyon

그리고 그랜드 캐니언은 역시 사진으로만 봤을 때랑 차원이 다르더라구요. 이게 정말로 사진으로 못담는게 한입니다.. 안가보신분들은 살면서 한번쯤은 꼭 봐야할 정도로 아름다운 경관이 펼쳐져있습니다! 제일 유명한 canyon답게 기념품 샵이나 이런것도 되게 잘되어있었고 박물관도 있었습니다.

후버댐 필드트립 & Goodbye Reception 2/27

후버댐 안 사진

2월 27일 오전에는 후버댐 필드트립을 갔습니다. 댐이 엄청 크고 역사도 오래됐더라구요. 전망대에서 콜로라도 강이 보이는 풍경을 봤는데, 이 물이 라스베이거스에 전기랑 물을 공급한다고 하니까 신기했습니다. 근데 이때도 너무 높아서 무서워서 제대로 못찍었습니다..

점심에는 Goodbye Reception이 있었어요. 고급 레스토랑에서 식사하면서 한 달 동안 같이한 Buddy, 교수님, 친구들이랑 마지막으로 인사하고 수료증도 받았습니다. "내가 여기를 다시 올 수 있을까?" 하는 생각에 좀 아쉬웠어요ㅜ 그래도 정말 좋은 시간이었습니다ㅎㅎ

귀국 2/28 출발 ~ 3/2 도착

카쇼(놀랍게도 관객석쪽 사진입니다)

2월 28일은 라스베이거스에서의 마지막 날이었어요. 오전에는 우리 프로젝트에 대한 발표를 했고, 점심에는 카쇼(KA by Cirque du Soleil)를 보러 갔습니다. 라스베이거스 마지막으로 꼭 보고 싶었던 쇼였는데 진짜 비현실적으로 이뻐서 넋 놓고 구경했습니다!

마지막 공항에서 굿바이 사진ㅜ

저녁에 비행기를 타고 한국으로 출발했습니다. 2월 28일 출발해서 3월 2일에 인천에 도착했어요. 비행기 창밖으로 라스베이거스가 점점 멀어지는 걸 보면서 한 달이 스쳐 지나갔다는 게 실감 났어요. 라스베이거스는 단순한 관광지가 아니라, 한 달간 살아본 집 같은 느낌이었습니다.

미국 여행 마무리!

"인천에서 출발해 라스베이거스에서 한 달을 살아보고, Valley of Fire, Bryce, 앤텔로프, 그랜드 캐니언, 호버댐, 카쇼까지. 다시 기회가 된다면 진심으로 꼭 또 가보고 싶어요.."

[UNLV] Las Vegas에서 한 달 여행기 - 상편

빡성 — Tue, 10 Mar 2026 16:47:27 +0900

Travel Journal · 1편

인천에서 라스베가스까지, 그리고 설레는 첫 2주

2025.02.01 ~ 02.13 Incheon → Las Vegas → UNLV

글로벌 AI 인재 트랙 참여로 라스베가스에 가게 되었습니다!

너무너무 재밌게 다녀와서 짧지만 한달간의 여정을 기록해보려 합니다ㅎㅎ

인천 → 라스베가스 출발 2/1

인천 -> 라스베가스 ✈️

인천공항에 도착하니 이제서야 한국을 떠난다는게 실감이 났습니다.. 장시간 비행기를 타는것도 처음이라 걱정도 됐지만 설레는 마음을 안고 출발했습니다!

라스베이거스 도착 & 호텔 체크인 2/1

스피어 뷰 짱!!

비행기가 내려앉으면서 창밖에 사막과 네온이 보이기 시작했습니다. 밖에 풍경을 보면서 이게 미국이구나.. 싶은 생각이 들면서 호텔에 도착하여 짐을 버스에서 내리는 도중에 호텔 뒷편을 바라보았는데 스피어가 보이면서 풍경이 너무너무 이뻐서 여기서 한 달을 산다는 생각에 잠깐 멍해졌습니다.

설레는 UNLV 첫 등교 & 캠퍼스 투어 2/2

UNLV캠퍼스 내 포토존(?)

다음 날, UNLV에 처음으로 등교해서 오리엔테이션과 캠퍼스 투어를 했는데, 미국 대학 캠퍼스는 처음이어서 모든 게 새로웠고 해외에서 공부한다는 설렘이 생겼습니다. 특히, 건물들 구조들이 신기하게 되어있었고 넓은 잔디들도 많았고 식당도 좋았습니다.

월마트에서 첫 장보기

캠퍼스 투어가 끝나고 버스를 타고 이동한 후 월마트에 갔습니다. 미국에서 생활용품을 사려면 여기서 사야한다는 말이 많았는데 역시나 없는게 없었습니다(이때, 여기서 더 많은 생필품을 샀어야하는데...)

분수쇼 & Fremont Street 2/2 저녁

분수쇼(사진으로 안담기는게 아숩..)

저녁을 먹고 나서 바로 분수쇼를 보러 갔습니다. 미국 오자마자 스케줄이 아주 빡세더군요..

물론 좋았습니다ㅎ 너무 아름다웠어요!! 봐도 또 보고싶은 느낌이었습니다.

음악에 맞춰 치솟는 물줄기, 주변 호텔과 네온, 영어로 말하는 사람들.. 등등 조화가 완벽했습니다.

"여행을 왔구나"라는 느낌이 이때 확 온거같아요.

Fremont Street

이어서 Fremont Street로 이동했는데요, 분명 대전에서 이런 느낌의 거리를 본 적이 있는거같은.. 생각이 들긴 했습니다. 위에는 짚라인 같은 걸 타는 사람들이 보였고 저희 학교 사람들도 몇명 타러갔지만 저는 타러가지않았습니다ㅜ 그래도 분위기는 제대로 즐긴거같아요! 이곳저곳 가게도 보고, 사람 구경도 하고, 공연같은것도 보면서 Vegas의 밤거리를 걸어다녔습니다.

본격 수업 & Buddy Program 2/3 ~ 2/6

OT수업(하루 수업 4시간 개꿀)

이제 본격적으로 학교에 가서 수업을 들었습니다. 정말 설렜어요! ~~처음에는 분명 수업이 설렜었죠...~~

수업실에 앉아 강의를 듣는데 역시 영어로 수업듣는게 쉽지 않았습니다. 전문 용어들이 숨 돌릴 틈도 없이 나왔기 때문에 한국어로 번역하는데만 뇌 용량을 다 쓴 것 같았어요ㅜ

그래도 한국에서 배운 적 없는 임베디드 내용도 배울 수 있다는게 기대가 됐습니다!

호텔에 있는 볼링장

수업 이후 저녁시간에 진행한 Buddy Program 덕분에 외국인 친구들과도 어울릴 수 있었습니다. 이때, 처음 안 사실이 이 프로그램을 같이 참여하는 외국인들이 처음엔 마냥 가이드인줄 알았는데, 모두 여기 UNLV에 다니는 대학생들이었습니다. (놀랍게도 우리보다 나이가 엄청 어렸다..) 볼링을 치러 갔을 때가 특히 기억이 나는데 이때를 기점으로 팀전으로 점수내기도 하면서 서로 웃고 떠들며 친해지게 되는 시간이었습니다.

피지컬 쩌는 형님들과 농구

수업이 끝나면 거의 매일 헬스장에도 가고 농구도 했는데 헬스장 시설이 너무너무 좋았고, 오랜만에 농구도 하며 학업 스트레스를 덜 수 있는 시간이었습니다. 그리고 외국인 형님들(?)과 같이 농구 경기도 했습니다ㅎ

첫 주말: North Outlet & 호텔 수영장 2/7 ~ 2/8

아울렛에서 한바탕 한 모습..

드디어 기다리고 기다리던 첫 주말!!!!! 아침 일찍부터 일어나서 옹기종기 모여 바로 North Outlet에 쇼핑하러 갔습니다. 브랜드도 많고 할인도 되고, 미국 아울렛이 처음이라 둘러보는 재미가 쏠쏠했습니다. 그중에서 맘에 드는 선글라스도 하나 구매하였는데 햇빛이 너무 쎄서 선글라스 없이는 견딜 수가 없더라고요.. 그래서인지 길을 다니다보면, 선글라스를 안끼고 다니는 미국인들이 거의 없을 정도였습니다.

캬

아울렛을 다녀온 뒤에는 호텔 수영장에서 햇살 좋은 날, 수영장에 누워 여유를 만끽했습니다. 평일엔 바쁘지만 주말에는 이렇게 쉬는 시간이 있어서 워라벨이 완벽했던 것 같아요ㅎㅎ

농구 경기, 그리고 Michael Jackson ONE 2/9 ~ 2/13

드론으로 촬영한 내모습

2월 9일, 수업이 다시 시작됐습니다.. 그래도 이번주에는 드론 수업을 했는데 드론 조종 원리부터 실제 비행까지, 처음 배우는 내용이어서 재밌었습니다. 특히, 매번 실습할때마다 느꼈던건데 장비들이 삐까뻔쩍해보여서 매우 좋았습니다.

UNLV 농구경기

2월 10일에는 UNLV 농구 경기를 관람하러 갔습니다. 타대학과의 대학농구 경기였는데 경기장이 대학교 안에 있는 것임에도 불구하고 스타디움처럼 엄청나게 컸던것과 관중석에서 응원하는 사람들이 많았다는게 되게 신기했습니다. 그리고 덩크를 밥먹듯이 하는것을 보고 유전자의 차이도 느낄 수 있었습니다..

Michael Jackson ONE공연

2월 13일. Michael Jackson ONE 공연을 봤습니다. 라스베가스가 유명한 쇼가 많다고 했는데 그 중 하나가 이거였나 생각하면서 봤던 것 같습니다. 무대 위에선 마이클 잭슨의 음악과 퍼포먼스가 살아 있었고, 공연장을 앞에만 쓰는 것이 아니라 관객석 쪽도 공연장으로 쓰는게 되게 좋았습니다. 그러나 기대를 많이해서 그런지 엄~청 재밌었다 까진 아니고 볼만 하다 정도였던 것 같습니다.

상편 마무리

"인천에서 출발해 라스베가스에 도착하고, UNLV 첫 등교부터 첫 주말, 농구 경기와 MJ ONE까지. 이제 워크숍이 벌써 절반이 지났네요. 후편에선 대망의 그랜드캐니언으로 뵙겠습니다."

→ 하편 예고: 그랜드캐니언, 호버댐, 수료식, 귀국

[UNLV] - 온라인 머신러닝과 이상 탐지: 이론과 진동 센서 실습 (13일차)

빡성 — Tue, 24 Feb 2026 07:38:25 +0900

수업 개요
온라인 머신러닝: 배치 학습과의 비교
이상 탐지의 정의와 전통적 방법
딥러닝 기반 이상 탐지 아키텍처
평가 지표, 요약 및 모델 선택
실습: 진동 스트리밍·온라인 학습·이상 탐지
정리

1. 수업 개요

이번 수업은 온라인 머신러닝(Online Machine Learning)의 철학(배치 학습과의 비교, 스트리밍 환경에서의 평가·윈도우 전략, SGD·Hoeffding Tree, 개념 드리프트·ADWIN·Half-Space Trees, 연합 온라인 학습)과 이상 탐지(Anomaly Detection) 이론(전통적 방법·딥러닝 재구성 기반)을 다룬다. 실습에서는 라즈베리파이(또는 센서 보드)에서 진동·가속도 데이터를 PC로 스트리밍한 뒤, 호스트 PC에서 온라인 분류(Hoeffding Tree), 개념 드리프트 감지(ADWIN), 이상 탐지(Autoencoder 등), 필요 시 연합 학습까지 진행하는 구성을 다룬다.

2. 온라인 머신러닝: 배치 학습과의 비교

온라인 머신러닝은 데이터가 생성되는 즉시 학습에 반영하는 동적 학습 체계이다.

배치 vs 온라인

전통적 머신러닝 (Batch Learning): 고정된 데이터셋(CSV 등)을 한꺼번에 학습한다. 데이터가 바뀌면 전체를 다시 학습해야 하므로 자원 소모가 크다. 식으로는 Model = Train(X_all, Y_all)에 해당한다.
온라인 머신러닝 (Incremental Learning): 스트림에서 새 샘플이 도착할 때마다 모델을 즉시 갱신한다. Model_t = Update(Model_{t-1}, X_new, Y_new) 형태로, 한 번에 한 인스턴스(또는 소량의 미니배치)만 사용한다.

필요성: (1) 대용량·스트리밍 — 서버 로그처럼 RAM을 초과하는 데이터를 다룰 때 필수적이다. (2) 역동적 환경 — 사용자 패턴·센서 데이터가 실시간으로 변할 때 유리하다. (3) 엣지 컴퓨팅 — 라즈베리 파이 같은 저사양 기기에서 대용량 저장 없이 AI를 운영할 수 있다. (4) 콜드 스타트 완화 — 방대한 데이터가 쌓일 때까지 기다리지 않고 바로 가동할 수 있다.

핵심 용어와 평가

실시간 스트리밍에서는 기존의 학습/테스트 분리가 그대로 통하지 않는다.

인스턴스(Instance): 시간 t에 도착하는 단일 데이터 포인트 (x, y)이다.
Interleaved Test-Then-Train: 들어온 데이터로 먼저 예측을 수행하고, 이후 실제 정답이 확인되면 그 데이터를 바로 학습에 사용하는 표준 방식이다.
리그렛(Regret): 온라인 모델과 (모든 데이터를 알고 있다고 가정한) 가상의 최적 정적 모델 간의 성능 차이이다. 이 값이 작을수록 온라인 모델이 잘 적응하고 있다는 의미이다.

윈도우 전략 (Windowing)

데이터의 ‘신선도’를 유지하기 위해 어떤 데이터를 기억하고 버릴지 결정하는 방법이다.

Sliding Window: 최근 N개의 샘플만 유지하는 가장 보편적인 방식(FIFO)이다.
Damped Window: 최근 데이터에는 높은 가중치를, 오래된 데이터에는 지수적으로 감소하는 낮은 가중치를 부여한다.

알고리즘: 선형 모델과 트리

온라인 학습의 성능은 모델이 얼마나 빠르게 갱신되느냐에 좌우된다.

SGD (Stochastic Gradient Descent): 온라인 학습의 기반이다. 오차가 발생할 때마다 가중치를 소량씩 조정하며, 회귀·SVM 등에 널리 쓰인다.
Hoeffding Trees (VFDT): 스트리밍용 의사결정 나무이다. 노드 분할 시 Hoeffding Bound를 사용한다. 식은 ε = √(R² ln(1/δ) / (2n)) 이며, n개 샘플이 쌓였을 때 현재 관찰된 최선의 분할이 진정한 최적임을 통계적으로 보장한다. 이 ε이 일정 수준 이하로 떨어져야 비로소 노드를 분할해 모델이 정교해진다.

개념 드리프트 (Concept Drift)와 ADWIN

온라인 환경의 큰 도전은 정답이 변하는 현상이다. 계절에 따라 온도의 ‘정상’ 범위가 달라지듯, 데이터의 통계적 특성이 바뀌는 것을 개념 드리프트라 한다. Sudden(갑작스러운 사고), Gradual(센서 노후화), Recurring(계절성) 유형이 있다. ADWIN은 스트림의 변화를 감지해 윈도우 크기를 자동으로 조절하거나, 감지 시 윈도우를 리셋해 드리프트 이후 데이터만 반영하도록 한다.

Half-Space Trees (HST)와 이상 탐지

공간을 무작위로 분할해, 데이터가 희소한(Sparse) 영역에 떨어지면 이를 이상치로 판단하는 비지도 학습 방식이다. 라벨 없이 스트리밍 이상 탐지에 활용할 수 있다.

연합 온라인 학습 (Federated Online Learning)

프라이버시와 실시간 성능을 동시에 만족시키는 방식이다. 라즈베리 파이 같은 엣지 기기가 로컬에서 데이터를 즉시 학습하고, 데이터 자체가 아닌 업데이트된 가중치(Weight)만 서버로 전송한다. 서버는 여러 기기의 가중치를 합산해 글로벌 모델을 만들고 다시 기기들에 배포한다. 데이터 유출 없이 대규모 협업 학습이 가능하다.

3. 이상 탐지의 정의와 전통적 방법

이상 탐지란?

정의: 데이터셋의 일반적인 패턴이나 행동에서 크게 벗어나는 데이터 포인트, 이벤트, 또는 관측치를 식별하는 기술이다. 건초 더미 속의 바늘을 찾는 것과 같다. 실제 환경에서는 이상치가 매우 드물기 때문에(보통 전체의 1% 미만) 정확히 찾아내는 것이 어렵다.

세 가지 주요 유형

점 이상(Point Anomalies): 개별 데이터 포인트 하나가 나머지와 멀리 떨어진 경우. 예: 신용카드 부정 사용.
문맥적 이상(Contextual Anomalies): 특정 상황에서만 이상으로 간주되는 경우. 예: 여름의 30°C는 정상이지만 겨울의 30°C는 이상.
집단적 이상(Collective Anomalies): 개별 데이터는 정상일 수 있으나, 그 시퀀스나 집합이 비정상인 경우. 예: 불규칙한 심장 박동.

왜 딥러닝인가? (전통적 머신러닝과의 차이)

전통적 방법의 한계: Isolation Forest나 One-Class SVM 같은 기존 방식은 이미지, 비디오 같은 고차원 데이터나 복잡한 비선형 관계를 다루기 어렵다.

딥러닝의 장점: (1) 특징 학습 — 수동으로 특징을 뽑지 않고 계층적 표현을 자동으로 학습한다. (2) 확장성 — 대규모 데이터를 효과적으로 처리할 수 있다. (3) 비정형 데이터 — 이미지, 오디오, 시계열 데이터 처리에 강하다.

Isolation Forest: 전통적 방식의 대표

데이터를 직접 모델링하기보다, 데이터를 고립(Isolate)시키는 데 집중하는 비지도 학습 알고리즘이다. 무작위 분할로 트리를 만들 때, 이상치는 정상 데이터보다 적은 횟수의 분할로도 쉽게 고립된다. 따라서 경로 길이(Path length)가 짧을수록 이상치일 확률이 높다고 판단한다. 표 형식 데이터나 저차원 특징에는 여전히 많이 쓰인다.

4. 딥러닝 기반 이상 탐지 아키텍처

재구성 기반 탐지 원리

딥러닝 이상 탐지의 핵심 아이디어는 재구성(Reconstruction)이다. 가설: 정상 데이터로만 학습한 모델은 정상 데이터는 잘 복원하지만, 이상치를 넣으면 복원에 실패한다. 지표: 입력과 출력의 차이인 재구성 오차(Reconstruction Error, MSE 등)를 쓴다. 오차가 낮으면 정상, 높으면 이상으로 본다.

주요 아키텍처

Autoencoder (AE): 입력을 잠재 공간(Latent space)으로 압축했다가 다시 복원하는 구조. 정상 샘플로만 학습해 재구성 손실을 최소화한다.
Variational Autoencoder (VAE): 일반 AE는 입력을 고정된 점으로 인코딩하는 반면, VAE는 평균(μ)과 분산(σ²)을 가진 확률 분포로 인코딩한다. 잠재 공간이 더 부드러워지고 이상 점수를 확률적으로 계산하기 좋다.
LSTM Autoencoder: 로그·센서 같은 시계열 데이터에 맞춘 구조. LSTM으로 시간적 의존성을 잡고, 재구성 오차로 이상을 판단한다.
GAN (AnoGAN): 생성자(G)는 정상 데이터를 생성하도록, 판별자(D)는 가짜를 걸러내도록 학습한다. 추론 시 특정 입력을 잘 생성하지 못하거나 판별자가 거부하면 이상으로 본다.

5. 평가 지표, 요약 및 모델 선택

평가 지표와 임계값

이상 탐지에서는 데이터 불균형이 심하므로 정확도(Accuracy)만 믿으면 안 된다. 임계값(Threshold)은 고정값이나 통계적 방법(예: 평균 + 3×표준편차)으로 정한다. 주요 지표: 정밀도(Precision), 재현율(Recall), F1-Score, AUROC로 성능을 종합 평가한다.

요약 및 권장 사항

데이터 준비: 신경망 학습 전에 데이터를 [0, 1] 범위로 정규화하는 것이 일반적이다.

데이터 유형별 모델 선택: 표 형식(Tabular) → AE/VAE. 시계열(Time-Series) → LSTM/Transformer. 이미지 → Convolutional AE / GAN.

주의사항: 학습 데이터에 이상치가 섞여 들어가는 오염(Contamination)을 피해야 한다. 이상치까지 정상으로 학습하면 탐지 성능이 떨어진다.

6. 실습: 진동 스트리밍·온라인 학습·이상 탐지

구성

라즈베리파이(또는 M5Core 등)가 가속도·진동 데이터를 수집해 TCP로 스트리밍하고, 호스트 PC가 이를 받아 온라인 학습과 이상 탐지를 수행한다. 센서로는 BMI160·MPU6050 같은 IMU(가속도계)를 사용해 X, Y, Z 축 가속도 값을 일정 주기(예: 20Hz)로 전송한다. 호스트는 수신한 패킷을 JSON으로 파싱한 뒤, 특징(ax, ay, az, 또는 윈도우 통계)을 추출해 온라인 분류기·이상 탐지기에 넣는다.

실습에서는 (1) 온라인 분류: 슬라이딩 윈도우로 윈도우별 통계(std_x, std_y, std_z, mean_x 등)를 만들고, River의 StandardScaler + HoeffdingTreeClassifier로 “정지(IDLE)” vs “진동(MOTION)”을 Test-Then-Train 방식으로 학습·예측한다. (2) 개념 드리프트: ADWIN으로 스트림의 평균 변화를 감지하는 데모(합성 스트림 또는 실데이터)를 통해 드리프트 시점을 확인한다. (3) 연합 학습: 엣지 클라이언트가 로컬에서 학습한 뒤 가중치만 서버(Flower 등)로 보내고, 서버가 FedAvg로 집계한 글로벌 모델을 다시 배포하는 흐름을 경험할 수 있다.

두 단계: 캘리브레이션 → 탐지

1단계(캘리브레이션): 센서를 정지 상태로 두고 일정 개수(예: 200~1000개)의 “정상” 샘플만 수집한다. 이 구간에서는 사용자가 진동을 주지 않는다. 수집이 끝나면 이 데이터만으로 모델을 학습(또는 통계 기준을 잡는다).

2단계(탐지): 학습이 끝나면 실시간으로 들어오는 샘플마다 이상 여부를 판단한다. 전통적 방법(Isolation Forest)이면 fit된 모델로 predict·decision_function을 쓰고, 통계적 방법(Z-Score)이면 최근 구간의 평균·표준편차를 기준으로 Z값을 계산해 임계값을 넘으면 이상으로 친다. 딥러닝 방법(Autoencoder)이면 정규화된 입력을 재구성한 뒤 MSE를 구하고, 학습 시 정해둔 임계값(예: 학습 재구성 오차의 평균+3×표준편차, 또는 최대×1.1)과 비교한다.

세 가지 탐지 방식

Z-Score 기반: 최근 N개 샘플의 진동 크기(또는 축별 값)에 대해 평균과 표준편차를 구하고, 현재 값의 Z-Score가 임계값(예: 3.5)을 넘으면 이상. 구현이 단순하고 별도 학습이 없지만, 구간 길이와 임계값 설정에 따라 민감도가 달라진다.
Isolation Forest: 수집한 정상 데이터로 Isolation Forest를 학습한다. 추론 시 1=정상, -1=이상으로 예측하고, decision_function 점수(음수일수록 이상에 가깝다)를 함께 쓸 수 있다. contamination 파라미터로 민감도를 조절한다.
Autoencoder: 입력 차원(예: 3)을 잠재 차원(예: 2)으로 압축했다가 다시 3으로 복원하는 AE를 정상 데이터로만 학습한다. Min-Max 정규화 후 MSE 손실로 학습하고, 학습 데이터의 재구성 오차 분포를 보고 임계값을 정한다(평균+3×표준편차 또는 최대 오차×여유 계수). 실시간으로 들어오는 샘플의 재구성 오차가 임계값을 넘으면 이상으로 판단한다.

테스트 방법

먼저 센서를 움직이지 않고 정상 데이터만 모아 캘리브레이션·학습을 끝낸다. 그다음 Z축 방향으로 살짝 두드리거나 흔들어 인위적인 진동(이상치)을 준다. 이상 탐지기에서는 재구성 오차가 임계값을 넘으면 “ANOMALY”로, 온라인 분류기에서는 “MOTION” 등으로 표시된다. 콘솔에 해당 메시지가 뜨면 동작이 확인된다. 정상일 때는 “NORMAL” 또는 “IDLE”로 표시되며, 재구성 오차나 점수가 임계값 아래로 유지되는지 보면 된다.

7. 정리

이번 수업에서는 온라인 머신러닝의 철학(배치 vs 스트리밍, 인스턴스·Test-Then-Train·리그렛, 슬라이딩·댐핑 윈도우, SGD·Hoeffding Tree, 개념 드리프트·ADWIN·Half-Space Trees, 연합 온라인 학습)과 이상 탐지의 정의(점·문맥·집단 이상), 전통적 방법(Isolation Forest), 딥러닝 재구성 접근(AE, VAE, LSTM-AE, GAN), 평가 지표·실무 지침(정규화, 데이터 유형별 모델, Contamination 주의)을 정리했다. 실습에서는 라즈베리파이(또는 센서 보드)에서 진동·가속도 데이터를 스트리밍하고, 호스트 PC에서 온라인 분류(Hoeffding Tree), 개념 드리프트 감지(ADWIN), 이상 탐지(Z-Score, Isolation Forest, Autoencoder), 필요 시 연합 학습까지 진행했다. 센서를 멈춘 상태에서 정상 기준을 학습한 뒤, 진동을 주어 이상을 유도해 탐지·분류기가 반응하는지 확인하는 흐름으로 진행했다.

[UNLV 프로젝트] - 프로젝트 설명과 내 역할, 진행 내용

빡성 — Tue, 24 Feb 2026 03:51:18 +0900

프로젝트가 하는 일
AoII와 시스템 구성
데이터 흐름과 ML 모델
내 역할과 맡은 부분
지금까지 진행한 작업
장애가 날 수 있는 지점
앞으로 발전시킬 것들
마치며

1. 프로젝트가 하는 일

이 프로젝트는 엣지 디바이스(ESP32)에서 온·습도 센서(AHT20/21) 값을 읽고, 작은 예측 모델(MLP, Rolling Window 4단계·12-64-32-2 ReLU)로 “다음 온·습도”를 추정한다. 예측이 괜찮으면 전송하지 않고, 예측 오차가 임계값을 넘을 때만 433MHz LoRa로 한 번 보낸다. 그렇게 해서 통신 횟수·전력을 줄이면서도, 게이트웨이와 엣지 모두에서 실제값을 받을 때마다 온라인 학습으로 같은 모델을 유지·동기화한다. 수집된 데이터는 MQTT를 한 번 발행한 뒤, 구독자가 MySQL·CSV에 각각 저장하고, Flask 대시보드·API·Prometheus 메트릭·Grafana로 모니터링한다. 실험 시간대는 라스베이거스(UTC-8) 기준으로, 엣지·게이트웨이 모두 “하루 중 시간 비율(time_n, 0~1)”을 입력으로 쓴다. 한 줄로 말하면, “필요할 때만 보내고, 엣지와 게이트웨이가 같은 모델로 함께 학습하는 IoT + AoII 실험 시스템”이다.

2. AoII와 시스템 구성

AoII(Age of Incorrect Information)란?

“잘못된 정보가 얼마나 오래 유지되는가”를 재는 지표다. IoT·센서 네트워크에서는 데이터를 매번 보내지 않고도 원격지가 현재 상태를 잘 추정하게 만드는 연구와 연결된다. 이 프로젝트에서는 온도 오차 β_temp(0.5°C) 또는 습도 오차 β_hum(3%) 이상일 때, 또는 10분 주기 하트비트, 시간 미동기화일 때만 전송한다. 그 외에는 전송을 생략(SKIP)해 전력을 아끼고, 전송 횟수·오차·수신 데이터를 DB·CSV·메트릭으로 쌓아 AoII·전송 효율·모델 성능을 분석할 수 있게 했다.

시스템 구성 상세

엣지: Heltec WiFi LoRa 32 v2, AHT20/21 온습도, 433MHz LoRa, OLED. 1분 주기로 light sleep 후 측정·예측·전송 조건 판단을 한다. 전송 조건을 만족하면 LoRa로 “온도,습도” 문자열을 보내고, 게이트웨이에서 시리얼로 넘겨 주는 Unix 시간을 받아 시간 동기화 후 엣지 MLP를 한 번 온라인 학습한다. 시간만 요청할 때는 Ping(0.0, 0.0) 같은 특수 패킷을 쓰고, 응답으로 시간만 받을 수 있다. USB 시리얼로 매 주기마다 SKIP/SEND/HEARTBEAT 등 한 줄 로그를 출력해, 별도 로거로 수집해 DB에 남길 수 있다.

게이트웨이(하드웨어): ESP32 + LoRa. 엣지 패킷을 받으면 수신 내용을 그대로 USB 시리얼로 전달한다. ML 연산은 하지 않고, 게이트웨이 소프트웨어가 시리얼을 읽어 처리한다.

게이트웨이(소프트웨어): 시리얼 포트는 설정 파일(.env)에서 지정한다(맥북 예: /dev/cu.usbserial-3, 라즈베리파이 예: /dev/ttyUSB0). 시리얼에서 “Received: 온도,습도” 형태의 문자열을 파싱해 실제 온·습도를 얻고, 엣지와 동일한 12-64-32-2 MLP로 현재 상태에서 예측한 뒤 실제값으로 온라인 학습(역전파)을 수행한다. 그다음 MQTT 브로커(설정에서 주소·포트 지정, 라즈베리파이에서 실행 시 보통 localhost, 맥북에서 실행 시 라즈베리파이 IP)로 특정 토픽(예: aoii/readings)에 JSON을 발행한다. 이벤트 종류는 두 가지다.

RX: 엣지에서 데이터를 수신했을 때(실제 온·습도, 예측값, 오차, 누적 전송 횟수 등 포함)

EST: 60초마다 게이트웨이만의 예측값을 보낼 때. RX가 발생하면 엣지에게 시리얼로 Unix 시간을 보내 ACK 역할을 한다.

메시지 브로커: Mosquitto를 라즈베리파이에서 실행한다(기본 포트 1883). 외부에서 접속하려면 listener를 0.0.0.0으로 두고, 필요 시 allow_anonymous 등 설정을 한다. 발행·구독은 하나의 토픽으로 중개된다.

저장: 구독자 두 개를 둘 수 있다.

(1) DB 저장: event=RX인 메시지만 MySQL의 readings 테이블에 insert한다. 맥북에서 MySQL을 쓰고 이 구독자를 실행하면, created_at은 로컬 시간으로 저장해 대시보드·CSV와 맞춘다.

(2) CSV 저장: RX·EST 모두 프로젝트 루트의 experiment_log_online.csv에 한 줄씩 append한다. 라즈베리파이에서 이 구독자만 실행하면 Pi에 CSV가 쌓여 실험 로그·재현용으로 쓴다.

(3) 선택적으로 엣지 USB 시리얼을 읽는 로거를 두어, SKIP/SEND/HEARTBEAT 구분으로 edge_log 테이블에 남길 수 있다.

모니터링: Flask 서버는 DB에서 통계(get_stats)·최근 데이터(get_recent)를 조회해 대시보드(차트·통계)와 API(/api/stats, /api/recent)를 제공한다. 동시에 Prometheus 형식의 /metrics 엔드포인트를 노출해, aoii_readings_total(총 수신 횟수), aoii_mae_temp(온도 평균 절대 오차) 등 메트릭을 준다. Prometheus는 설정(prometheus.yml)에 따라 이 /metrics를 주기적으로 스크래핑하고, Grafana는 Prometheus를 데이터 소스로 연결해 대시보드·알람을 만든다.

3. 데이터 흐름과 ML 모델

데이터 흐름 (단계별)

1단계 — 엣지: AHT로 온도·습도를 측정한다. 입력은 과거 4시점의 (온도, 습도, time_n)을 펼친 12차원이다. 12-64-32-2 MLP로 “다음 예측 온도·습도”를 낸 뒤, 실제 측정값과 비교해 err_t ≥ β_temp(0.5°C) 또는 err_h ≥ β_hum(3%)이면, 또는 10분 하트비트 구간이면, 또는 시간이 아직 동기화되지 않았으면 LoRa로 “온도,습도”를 전송한다. 전송한 경우에는 게이트웨이 ESP32가 시리얼로 넘겨 주는 Unix 시간을 LoRa로 받아 시간을 맞추고, 방금 보낸 실제값으로 엣지 MLP를 한 번 역전파(온라인 학습)한다.

2단계 — 게이트웨이 ESP32: LoRa로 엣지 패킷을 받으면 수신 문자열(예: “Received: 25.3,60.2”)을 USB 시리얼로 그대로 PC 또는 라즈베리파이에 전달한다. Ping 0.0,0.0이면 시간 요청/응답만 처리할 수 있다.

3단계 — 게이트웨이 소프트웨어: 시리얼에서 “Received: ...”를 파싱해 실제 온·습도를 얻는다. 동일한 12-64-32-2 MLP로 현재 상태에서 예측한 뒤, 이 실제값으로 온라인 학습(online_update)을 호출해 가중치를 갱신한다. MQTT로 aoii/readings 토픽에 JSON을 발행한다. event=RX(엣지 수신 시) 또는 60초마다 event=EST(게이트웨이만의 예측). 페이로드에는 timestamp, time_n, actual_t, actual_h, pred_t, pred_h, error_t, error_h, total_tx 등이 들어간다. RX일 때는 엣지에게 시리얼로 Unix 시간을 보내 ACK·시간 동기화를 한다.

4단계 — MQTT 구독자: DB 저장 구독자는 event=RX인 메시지만 MySQL readings 테이블에 insert한다(맥북에서 실행). CSV 저장 구독자는 RX·EST 모두 experiment_log_online.csv에 한 줄씩 append한다(라즈베리파이에서 실행 시 Pi에 파일 생성).

5단계 — 모니터링: Flask는 DB에서 get_stats·get_recent를 조회해 대시보드·API를 제공하고, /metrics에서 Prometheus 메트릭을 노출한다. Prometheus가 이를 스크래핑하고, Grafana에서 시각화·알람을 구성한다.

ML 모델 (12-64-32-2 MLP, Rolling Window)

구조: 입력 12(과거 4시점의 온도·습도·time_n을 펼친 벡터) → 은닉층 64(ReLU) → 은닉층 32(ReLU) → 출력 2(예측 온도, 예측 습도). 엣지와 게이트웨이에 동일한 구조·가중치를 둔다.

사전 학습: 사전에 수집한 데이터셋(타임스탬프, 온도, 습도)으로 Rolling Window(크기 4)를 적용해 12차원 입력·2차원 출력 데이터를 만들고, sklearn MLPRegressor 12-64-32-2(ReLU)를 학습한 뒤, 가중치와 스케일러(정규화 파라미터)를 추출해 엣지에는 C 배열로, 게이트웨이에는 Python으로 동일하게 반영한다.

온라인 학습: 전송이 일어날 때마다 엣지·게이트웨이 모두 실제값(방금 수신한 온·습도)으로 역전파를 한 번 수행한다. 학습률은 0.05 등으로 고정해 두고, 같은 데이터로 갱신하므로 양쪽 모델이 계속 동기화된다.

비교 실험: “온라인 학습 없이 고정 모델만 쓰는 경우”(오프라인 TinyML 비교군)는 게이트웨이에서 online_update 호출만 주석 처리하면 된다. CSV·DB에 event, total_tx, error_t, error_h가 쌓이므로, β 변경·학습 여부에 따른 전송 횟수·MAE 비교가 가능하다.

4. 내 역할과 맡은 부분

이 프로젝트에서 나는 데이터 파이프라인 설계·구현, 설정·저장·모니터링 정리, 그리고 장애 지점 파악·보완 과제 정리를 맡았다. 엣지 펌웨어나 LoRa 통신 프로토콜 자체보다는, 게이트웨이가 받은 패킷을 어디로 보낼지(한 번만 MQTT 발행), 누가 DB에 넣고 누가 CSV에 넣을지(구독자 분리), 시리얼 포트·MQTT 브로커 주소·DB 비밀번호는 어디에 두는지(.env 단일 소스), DB·CSV·대시보드의 시간을 어떻게 맞출지(로컬 시간 저장), 파이프라인 어디가 끊기면 어떤 영향인지(장애 지점 표), 장애가 생기면 무엇을 더 해야 하는지(QoS·DLQ·재시도·백업·런북 등)를 문서와 코드로 정리하는 쪽에 기여했다.

5. 지금까지 진행한 작업

이벤트 기반 파이프라인으로 전환

원래는 게이트웨이가 수신할 때 DB와 CSV에 직접 쓰는 구조였다. DB 연결 실패나 CSV 쓰기 실패가 나면 한 경로 장애가 전체 저장 실패로 이어질 수 있어서, 게이트웨이는 수신 시 MQTT로 한 번만 발행하도록 바꿨다. DB 저장은 “RX만 MySQL readings 테이블에 insert하는 구독자”, CSV 저장은 “RX·EST 모두 experiment_log_online.csv에 append하는 구독자”가 각각 구독해 처리한다. 발행부와 저장부를 분리해 장애 격리가 되었고, 나중에 저장 채널을 추가하거나(예: 다른 DB, 다른 파일) 변경할 때도 구독자만 추가·수정하면 된다.

분산 환경 역할 분리·문서화

라즈베리파이에는 MQTT 브로커(Mosquitto)와 CSV 저장 구독자만 실행하고 MySQL은 설치하지 않는다. 맥북에서는 게이트웨이 프로세스(시리얼 수신), MySQL, DB 저장 구독자를 실행한다. “어디서 무엇을 실행할지”, 실행 순서(예: 브로커 → 게이트웨이 → 구독자), 포트·토픽 이름(aoii/readings 등)을 MQTT·모니터링 문서에 정리해 두었다.

설정·비밀정보 단일 소스

여러 스크립트가 각자 설정 파일을 갖지 않고, 프로젝트 루트의 .env 한 곳만 읽도록 통일했다. SERIAL_PORT, MQTT_BROKER, MQTT_PORT, MYSQL_HOST, MYSQL_USER, MYSQL_PASSWORD 등 필요한 키를 .env에 두고, .env는 git에서 제외한다. 팀원에게는 “필요한 키 목록 + 예시값”만 공유하고, 실제 비밀번호는 직접 채우도록 했다. mysql_example.env 같은 중복 예시 파일은 제거했다.

데이터 정합성(시간)

DB에만 UTC로 저장하고 CSV·모니터링은 로컬 시간을 쓰다 보니 8~9시간 차이가 났다. DB 저장 시 insert_reading·insert_edge_log에서 created_at을 로컬 시간으로 기록하도록 수정해, 대시보드·CSV와 맞춰 두었다.

모니터링·문서 정리

Flask의 /metrics 노출 → Prometheus가 prometheus.yml 설정대로 스크래핑 → Grafana에서 Prometheus를 데이터 소스로 연결하는 절차와, aoii_readings_total, aoii_mae_temp 등 메트릭 목록을 MONITORING.md에 정리했다. MQTT.md, MONITORING.md를 “실행 순서·역할·설정” 중심으로 재구성해, 새로 합류한 사람이 어디서 무엇을 켜야 하는지 따라 할 수 있게 했다.

코드·중복 정리

루트에 있던 중복 게이트웨이 스크립트를 삭제하고, RX 이벤트가 두 번 로그에 찍히던 부분을 제거했다. 시리얼 포트·MQTT 브로커 주소 등은 모두 .env에서 읽도록 환경 변수화해, 설정 변경은 .env 한 곳에서만 하면 되도록 했다. Prometheus가 생성하는 data/ 폴더 용도도 문서에 적어 두었다.

6. 장애가 날 수 있는 지점

파이프라인은 “엣지 → LoRa → 게이트웨이 ESP32 → USB 시리얼 → 게이트웨이 소프트웨어 → MQTT 브로커(라즈베리파이) → mqtt_to_csv / mqtt_to_mysql” 순이다. 구간별로 장애 가능 지점·영향·비고를 정리해 두었다.

시리얼: USB 케이블 분리, 잘못된 포트 지정, 다른 프로세스가 포트 점유(예: 아두이노 IDE 시리얼 모니터)하면 게이트웨이 소프트웨어가 데이터를 받지 못하고 전체 파이프라인 중단이 된다. 맥북에서 게이트웨이를 돌릴 때 시리얼 포트 충돌이 자주 원인이 된다.
게이트웨이 프로세스: 크래시, 맥북 슬립/종료 시 수신·MQTT 발행이 끊긴다. 이후 구간(브로커·구독자)에는 데이터가 들어오지 않는다. 단일 프로세스라 재시작 전까지 복구되지 않는다.
맥북–라즈베리파이 네트워크: Wi‑Fi 끊김, 라즈베리파이 전원 나감·재부팅 시 게이트웨이가 브로커에 접속하지 못하고, 맥북에서 돌리는 DB 저장 구독자도 브로커를 구독하지 못한다. 브로커가 라즈베리파이에 있으므로 네트워크 의존도가 크다.
MQTT 브로커(Mosquitto): 프로세스 종료, Pi 디스크 풀, Pi 전원 장애 시 모든 구독자에게 메시지 전달이 불가하다. 단일 브로커라 SPOF(단일 장애점)이다.
CSV 저장 구독자: 프로세스 종료, Pi 디스크 풀, 파일 권한 오류 시 CSV만 갱신되지 않는다. DB·MQTT 자체는 동작하므로 영향은 CSV 구간으로 한정된다.
DB 저장 구독자·MySQL: 구독자 프로세스 종료나 MySQL 다운·연결 한도 초과 시 DB에 insert가 되지 않는다. 현재 MQTT는 QoS 0이라 브로커가 메시지를 보관하지 않는다. 따라서 구독자가 다운된 시점에 발행된 메시지는 유실되고, 재시작 후에도 “그 사이” 메시지는 복구할 수 없다. MySQL 쪽에서 insert 실패 시 재시도가 없으면 해당 메시지 역시 유실된다.

요약하면, 전체 중단은 시리얼 단절·게이트웨이 중단·브로커 중단·맥북–Pi 네트워크 단절일 때이고, 부분 유실은 DB 저장 구독자·MySQL 장애 시 해당 구간 데이터 유실, 그리고 QoS 0으로 인한 “구독자 다운 시점 메시지 유실”이다.

7. 앞으로 발전시킬 것들

한 번 들어온 데이터는 유실 없이 처리·보관하고, 장애 시 빠르게 알아내고 복구할 수 있게 하려면 아래 같은 보완이 필요하다. 우선순위와 리소스에 맞춰 단계적으로 적용할 수 있다.

파이프라인·가용성

메시지 유실 방지: 현재 QoS 0은 브로커가 메시지를 저장하지 않아 구독자 다운 시 유실된다. QoS 1/2 또는 persistent session을 도입하면 구독자가 잠시 꺼져 있어도 브로커가 메시지를 보관·재전달할 수 있다. 채널 암호화·신뢰성 요구에 맞추려면 보통 보완이 필요하다.
Dead Letter Queue(DLQ): DB insert 실패 등 처리 실패 메시지를 별도 토픽·큐로 보내 두고, 원인(DB 다운, 스키마 오류 등)을 조치한 뒤 재처리(재생)할 수 있게 한다. 한 번은 반드시 처리하거나 보관하는 구조로 가져가는 것이 좋다.
브로커 이중화: 단일 Mosquitto는 SPOF이므로, 클러스터 또는 대기 브로커를 두어 장애 시 전환되도록 구성하면 가용성이 올라간다.
게이트웨이 자동 재기동: systemd·supervisor 등으로 게이트웨이 프로세스를 감시하고, 죽으면 자동 재시작하도록 한다. 가능하면 동일 역할을 하는 인스턴스를 여러 개 두는 것도 검토할 수 있다.

장애 대응·모니터링

헬스체크·알람: 이미 “수신 횟수·MAE” 등 메트릭이 있으므로, Grafana에서 “N분 이상 수신 없음”일 때 알람 규칙을 강화한다. 게이트웨이·MQTT·MySQL 프로세스가 살아 있는지 주기적으로 확인하는 헬스체크를 추가하면, 어느 구간에서 끊겼는지 빠르게 파악할 수 있다.
장애 시나리오 런북: “시리얼이 안 뜬다 → 포트 목록 확인, 다른 프로세스 점유 여부, 재연결” / “MQTT 연결 실패 → 브로커 주소·포트·네트워크 확인” / “MySQL 연결 실패 → 서비스 상태·연결 한도·비밀번호 확인” / “CSV가 안 쌓인다 → 구독자 프로세스·디스크·권한 확인”처럼 증상별 원인·확인 절차·조치를 문서(MD)로 정리해 두면 운영 시 유용하다.
메트릭 보강: “마지막 MQTT publish 성공 시각”, “구독자별 마지막 처리 시각”, “insert 실패 횟수” 등 파이프라인 구간별 메트릭을 추가하면, 어디서 지연·실패가 나는지 시각화·알람으로 잡기 쉬워진다.
로그 표준화: 에러·경고 시 시간·구간·에러 코드를 포함한 구조화된 로그를 남기고, 필요 시 중앙 수집(파일·에이전트)으로 추적하기 쉽게 한다.

데이터·운영 안정성

재시도·백오프: MySQL insert 실패 시 제한된 횟수·지수 백오프로 재시도하고, 그래도 실패하면 DLQ로 보낸다. 무한 재시도는 부하를 키우므로 막는 것이 좋다.
멱등성: 같은 메시지가 중복 수신돼도 중복 insert가 나지 않도록, 메시지 ID나 (timestamp, device) 같은 유니크 키로 제약을 두거나 “이미 있으면 skip” 로직을 넣는다.
백업·복구: DB·CSV 정기 백업과 보관 주기·삭제 정책을 정하고, 복구 절차(RPO/RTO)를 정의해 두면 장애 시 데이터 복구가 수월하다.
리텐션·용량: CSV·DB 보관 기간과 디스크 사용량을 추정하고, 오래된 데이터는 아카이빙·삭제하는 정책을 두어 디스크 풀을 방지한다.

보안·감사

MQTT 브로커·클라이언트 간 TLS 적용(채널 암호화 요구 대응), MySQL 연결 TLS·필요 시 민감 컬럼 암호화, 설정(.env)·중요 스크립트 배포 시 “누가/언제/무엇을” 변경했는지 이력 관리 절차를 검토한다.

설계·문서

엣지–게이트웨이–MQTT–구독자–DB/CSV 구간과 장애 지점을 한 그림에 표시한 아키텍처 다이어그램을 두면, 신규 합류자·운영자가 구조를 이해하기 쉽다. Part 2의 장애 지점 표를 확장해 “장애 유형 → 영향 구간 → 복구 절차” 매트릭스로 정리해 두는 것도 좋다. 용어(Gateway, 브로커, 구독자, readings 등)를 문서·코드 주석에서 통일하면 유지보수에 도움이 된다.

8. 마치며

이 프로젝트는 엣지 IoT에서 AoII를 고려한 “필요할 때만 전송”을 구현하고, 엣지와 게이트웨이에 같은 12-64-32-2 MLP를 두어 전송 시마다 온라인 학습으로 동기화하며, MQTT로 발행·구독을 나눠 수집·저장·모니터링을 분리한 구조다. 설정은 .env 단일 소스로 두고, 실행 순서와 역할은 MQTT·모니터링 문서를 참고하면 된다.

나는 그중에서 파이프라인 설계·이벤트 기반 전환(게이트웨이 → MQTT 한 번 발행, 구독자 분리), 분산 환경(라즈베리파이·맥북 역할 분리)·문서화, .env 단일 소스·비밀정보 관리, DB 시간 정합성(로컬 시간 저장), 모니터링 절차·메트릭 목록 정리, 코드·중복 제거, 그리고 “어디가 깨질 수 있는지”를 문서로 정리하는 역할을 했다.

앞으로는 메시지 유실 방지(QoS 1/2·persistent session·DLQ), 재시도·백오프·멱등성·백업, 헬스체크·알람·장애 시나리오 런북, 메트릭 보강, 필요 시 브로커 이중화·TLS·감사 절차를 단계적으로 적용하면, 실험용을 넘어 운영·서비스 관점에서도 더 견고한 시스템으로 발전시킬 수 있다.

[UNLV] - 이상 탐지: 이론과 진동 센서 실습(12일차)

빡성 — Sat, 21 Feb 2026 03:47:29 +0900

수업 개요
이상 탐지의 정의와 전통적 방법
딥러닝 기반 이상 탐지 아키텍처
평가 지표, 요약 및 모델 선택
실습: 진동 데이터 스트리밍과 이상 탐지
정리

1. 수업 개요

이번 수업은 이상 탐지(Anomaly Detection)의 정의, 전통적 방법(Isolation Forest), 딥러닝 방법(Autoencoder, VAE, LSTM-AE, GAN), 평가 지표를 이론으로 다루고, 실습에서는 라즈베리파이(또는 센서 보드)에서 가속도·진동 데이터를 PC로 스트리밍한 뒤, 호스트 PC에서 정상 데이터만으로 캘리브레이션·학습을 하고 실시간으로 이상을 탐지하는 구성을 진행했다.

2. 이상 탐지의 정의와 전통적 방법

이상 탐지란?

세 가지 주요 유형

점 이상(Point Anomalies): 개별 데이터 포인트 하나가 나머지와 멀리 떨어진 경우. 예: 신용카드 부정 사용.
문맥적 이상(Contextual Anomalies): 특정 상황에서만 이상으로 간주되는 경우. 예: 여름의 30°C는 정상이지만 겨울의 30°C는 이상.
집단적 이상(Collective Anomalies): 개별 데이터는 정상일 수 있으나, 그 시퀀스나 집합이 비정상인 경우. 예: 불규칙한 심장 박동.

왜 딥러닝인가? (전통적 머신러닝과의 차이)

전통적 방법의 한계: Isolation Forest나 One-Class SVM 같은 기존 방식은 이미지, 비디오 같은 고차원 데이터나 복잡한 비선형 관계를 다루기 어렵다.

Isolation Forest: 전통적 방식의 대표

3. 딥러닝 기반 이상 탐지 아키텍처

재구성 기반 탐지 원리

주요 아키텍처

Autoencoder (AE): 입력을 잠재 공간(Latent space)으로 압축했다가 다시 복원하는 구조. 정상 샘플로만 학습해 재구성 손실을 최소화한다.
Variational Autoencoder (VAE): 일반 AE는 입력을 고정된 점으로 인코딩하는 반면, VAE는 평균(μ)과 분산(σ²)을 가진 확률 분포로 인코딩한다. 잠재 공간이 더 부드러워지고 이상 점수를 확률적으로 계산하기 좋다.
LSTM Autoencoder: 로그·센서 같은 시계열 데이터에 맞춘 구조. LSTM으로 시간적 의존성을 잡고, 재구성 오차로 이상을 판단한다.
GAN (AnoGAN): 생성자(G)는 정상 데이터를 생성하도록, 판별자(D)는 가짜를 걸러내도록 학습한다. 추론 시 특정 입력을 잘 생성하지 못하거나 판별자가 거부하면 이상으로 본다.

4. 평가 지표, 요약 및 모델 선택

평가 지표와 임계값

요약 및 권장 사항

데이터 준비: 신경망 학습 전에 데이터를 [0, 1] 범위로 정규화하는 것이 일반적이다.

데이터 유형별 모델 선택: 표 형식(Tabular) → AE/VAE. 시계열(Time-Series) → LSTM/Transformer. 이미지 → Convolutional AE / GAN.

주의사항: 학습 데이터에 이상치가 섞여 들어가는 오염(Contamination)을 피해야 한다. 이상치까지 정상으로 학습하면 탐지 성능이 떨어진다.

5. 실습: 진동 데이터 스트리밍과 이상 탐지

구성

라즈베리파이(또는 M5Core 등)가 가속도·진동 데이터를 수집해 TCP로 스트리밍하고, 호스트 PC가 이를 받아 이상 탐지를 수행한다. 센서로는 MPU6050 같은 IMU(가속도계)를 사용해 X, Y, Z 축 가속도 값을 일정 주기(예: 20Hz)로 전송한다. 호스트는 수신한 패킷을 JSON으로 파싱한 뒤, 특징(ax, ay, az 또는 진동 크기)을 추출해 탐지기에 넣는다.

두 단계: 캘리브레이션 → 탐지

세 가지 탐지 방식

Z-Score 기반: 최근 N개 샘플의 진동 크기(또는 축별 값)에 대해 평균과 표준편차를 구하고, 현재 값의 Z-Score가 임계값(예: 3.5)을 넘으면 이상. 구현이 단순하고 별도 학습이 없지만, 구간 길이와 임계값 설정에 따라 민감도가 달라진다.
Isolation Forest: 수집한 정상 데이터로 Isolation Forest를 학습한다. 추론 시 1=정상, -1=이상으로 예측하고, decision_function 점수(음수일수록 이상에 가깝다)를 함께 쓸 수 있다. contamination 파라미터로 민감도를 조절한다.
Autoencoder: 입력 차원(예: 3)을 잠재 차원(예: 2)으로 압축했다가 다시 3으로 복원하는 AE를 정상 데이터로만 학습한다. Min-Max 정규화 후 MSE 손실로 학습하고, 학습 데이터의 재구성 오차 분포를 보고 임계값을 정한다(평균+3×표준편차 또는 최대 오차×여유 계수). 실시간으로 들어오는 샘플의 재구성 오차가 임계값을 넘으면 이상으로 판단한다.

테스트 방법

먼저 센서를 움직이지 않고 정상 데이터만 모아 캘리브레이션·학습을 끝낸다. 그다음 Z축 방향으로 살짝 두드리거나 흔들어 인위적인 진동(이상치)을 준다. 탐지기가 이를 이상으로 잡아내고, 콘솔에 “ANOMALY” 또는 유사 메시지가 뜨면 동작이 확인된다. 정상일 때는 “NORMAL” 등으로 표시되며, 재구성 오차나 점수 바가 임계값 아래로 유지되는지 보면 된다.

6. 정리

이번 수업에서는 이상 탐지의 정의(점·문맥·집단 이상), 전통적 방법인 Isolation Forest의 원리, 딥러닝 기반 재구성 접근(AE, VAE, LSTM-AE, GAN)과 평가 지표·임계값·데이터 유형별 모델 선택을 정리했다. 실습에서는 라즈베리파이(또는 센서 보드)에서 가속도 데이터를 스트리밍하고, 호스트 PC에서 정상만 수집한 뒤 Z-Score, Isolation Forest, Autoencoder 세 가지 방식으로 실시간 이상 탐지를 수행했다. 센서를 멈춘 상태에서 정상 기준을 학습하고, 이후 진동을 주어 이상을 유도해 탐지기가 반응하는지 확인하는 흐름으로 진행했다.

[UNLV] - 오프라인 음성 인식으로 Tello 드론 제어(11일차)

빡성 — Fri, 20 Feb 2026 03:18:26 +0900

수업 개요
실시간 드론 제어와 오프라인 음성 인식
음성 엔진 비교: Vosk, OpenWakeWord, PocketSphinx
실습 1: Vosk + Tello (네이티브 오디오)
실습 2: OpenWakeWord + Vosk (웨이크워드 후 명령)
실습 3: PocketSphinx + Tello
실습 4: 데이터셋·CNN 학습·임베디드 추론
정리

1. 수업 개요

이번 수업은 오프라인 음성 인식으로 Tello 드론을 실시간 제어하는 내용이다. 인터넷이 없어도 “Take off”, “Land”, “Stop” 같은 말을 인식해 드론을 조종할 수 있도록, PC에서 쓰기 좋은 엔진(Vosk, OpenWakeWord, PocketSphinx)과 마이크 라이브러리(SoundDevice)를 사용했다. 이론에서는 왜 실시간 드론 제어에 Vosk가 적합한지, Whisper와의 차이, 네이티브 오디오(SoundDevice)의 장점을 정리하고, 실습에서는 Vosk 단독 제어, OpenWakeWord(웨이크워드 “Hey Jarvis”) 후 Vosk 명령, PocketSphinx 제어, 그리고 Google Speech Commands 데이터셋·MFCC CNN 학습·TFLite·라즈베리파이·M5Core2 추론까지의 흐름을 다룬다.

2. 실시간 드론 제어와 오프라인 음성 인식

왜 Vosk인가? (Vosk vs Whisper)

음성을 글자로 바꾸는 STT(Speech-to-Text) 중에서 OpenAI의 Whisper는 정확도가 높지만, 실시간 드론 제어에는 Vosk가 더 적합하다.

지연 시간(Latency): Vosk는 오디오를 스트리밍으로 처리해 밀리초 단위 반응이 가능하다. Whisper는 보통 몇 초 단위 청크를 모아 처리하므로 지연이 크다. “Stop”이라고 했을 때 드론이 즉시 멈추려면 Vosk 같은 저지연 엔진이 필요하다.
경량성: Vosk는 일반 CPU만으로 동작하며, 무거운 GPU가 필요 없다. 노트북·RPi에서도 실행하기 쉽다.
설치: pip install vosk로 설치하고, 작은 언어 모델(vosk-model-small-en-us-0.15 등)을 받아 폴더만 두면 된다. Whisper나 다른 엔진은 빌드·의존성 문제가 생기는 경우가 많다.

네이티브 오디오: SoundDevice

Python 음성 인식에서 가장 까다로운 부분은 마이크 라이브러리다. PyAudio는 Windows·Mac에서 Visual Studio Build Tools, Homebrew, PortAudio 등 시스템 의존성을 요구해 설치가 번거롭다. 이 수업에서는 SoundDevice를 쓴다. SoundDevice는 Windows·macOS용 사전 빌드 바이너리(DLL/dylib)를 포함해, 별도 컴파일 없이 pip install sounddevice만으로 마이크 입력을 사용할 수 있다. 따라서 “네이티브” 방식으로 Mac·Windows 모두에서 동일한 코드가 동작하도록 구성했다.

3. 음성 엔진 비교: Vosk, OpenWakeWord, PocketSphinx

Vosk: 오프라인 STT. 스트리밍 처리, 낮은 지연, pip·소형 모델로 설치 간단. 드론 명령어(“take off”, “land”, “stop” 등) 인식에 적합.

OpenWakeWord: “Hey Jarvis” 같은 웨이크 워드만 감지하는 경량 모델. 항상 전체 어휘를 듣지 않고, 웨이크 워드가 나온 뒤에만 Vosk로 명령을 받으면 오인식과 배터리 소모를 줄일 수 있다.

PocketSphinx: 클래식한 오프라인 엔진. 설치 시 SWIG·C++ 빌드 도구가 필요해 Windows·Mac에서 설정이 다소 까다롭다. 짧은 단어(“up” 등)보다 “go up”, “go down”처럼 구문으로 인식시키면 정확도가 올라간다. SoundDevice로 녹음한 뒤 SpeechRecognition으로 PocketSphinx를 호출하는 방식으로 사용할 수 있다.

4. 실습 1: Vosk + Tello (네이티브 오디오)

4-1. 설치 및 모델 다운로드

터미널( Mac) 또는 명령 프롬프트(Windows)에서:

pip install vosk sounddevice djitellopy numpy

Vosk는 소형 언어 모델 폴더가 필요하다. (1) vosk-model-small-en-us-0.15(약 40MB) zip을 다운로드하고, (2) 압축을 푼 뒤 (3) 폴더 이름을 model 또는 vosk_model로 맞추고, (4) 프로젝트 폴더 안에 넣는다. 폴더 안에 am, conf, graph 등이 있어야 한다.

4-2. 제어 흐름

SoundDevice로 마이크에서 16kHz·16bit·모노 오디오를 받아, 큐를 통해 Vosk에 넘긴다. 한 문장이 완성되면 인식 결과를 파싱해 “take off”, “land”, “up”, “down”, “left”, “right”, “forward”, “back”, “stop”, “flip” 등으로 Tello를 제어한다. Tello 연결 실패 시 시뮬레이션 모드로 동작하도록 예외 처리해 두면 편하다.

Vosk + Tello 제어 — 핵심 구조

import sys, json, queue
import sounddevice as sd
from vosk import Model, KaldiRecognizer
from djitellopy import Tello

SPEED = 30
MODEL_PATH = "model"   # 또는 "vosk_model"

tello = Tello()
try:
    tello.connect()
    tello.streamoff()
    print(f"[SUCCESS] Battery: {tello.get_battery()}%")
except Exception as e:
    print(f"[WARN] Tello connection failed: {e}")
    tello = None

q = queue.Queue()
def callback(indata, frames, time, status):
    if status: print(status, file=sys.stderr)
    q.put(bytes(indata))

def parse_and_execute(text):
    if not text: return
    print(f" >> Heard: '{text}'")
    if not tello: return
    try:
        if "take off" in text: tello.takeoff()
        elif "land" in text: tello.land()
        elif "up" in text: tello.move_up(SPEED)
        elif "down" in text: tello.move_down(SPEED)
        elif "left" in text: tello.move_left(SPEED)
        elif "right" in text: tello.move_right(SPEED)
        elif "forward" in text: tello.move_forward(SPEED)
        elif "back" in text: tello.move_back(SPEED)
        elif "stop" in text: tello.send_rc_control(0,0,0,0)
        elif "flip" in text: tello.flip_forward()
    except Exception as e: print(f"Command Error: {e}")

model = Model(MODEL_PATH)
rec = KaldiRecognizer(model, 16000)
with sd.RawInputStream(samplerate=16000, blocksize=8000, dtype='int16', channels=1, callback=callback):
    while True:
        data = q.get()
        if rec.AcceptWaveform(data):
            result = json.loads(rec.Result())
            parse_and_execute(result.get("text", ""))

5. 실습 2: OpenWakeWord + Vosk (웨이크워드 후 명령)

5-1. 구성

(1) OpenWakeWord가 “Hey Jarvis”를 감지하면 (2) 명령 모드로 전환해 (3) Vosk가 “Take off”, “Up” 등의 명령을 인식하고 Tello를 제어한다. SoundDevice로 16kHz PCM을 받아, 웨이크 워드 구간에는 OpenWakeWord에만 넘기고, 명령 모드일 때만 Vosk에 넘긴다.

5-2. 설치 및 모델

pip install sounddevice numpy openwakeword vosk djitellopy

Tello는 Wi‑Fi로 연결되므로, 연결 전에 모델을 미리 받아 두어야 한다. Vosk 모델은 위와 같이 폴더로 준비하고, OpenWakeWord 모델은 라이브러리에서 제공하는 다운로드 함수를 한 번 실행해 받아 둔다.

OpenWakeWord 모델 다운로드

import openwakeword
openwakeword.utils.download_models()
print("OpenWakeWord models downloaded!")

5-3. 실행 흐름

“웨이크 워드 대기”와 “명령 청취”를 플래그로 구분한다. OpenWakeWord 예측값이 임계값(예: 0.5)을 넘으면 명령 모드로 바꾸고 Vosk 버퍼를 리셋한 뒤, 이후 오디오는 Vosk로만 넘긴다. Vosk가 문장을 완성하면 해당 명령으로 드론을 제어하고, 다시 웨이크 워드 모드로 돌아간다.

웨이크 워드 감지 후 Vosk 명령 처리

# 웨이크 워드 대기 중일 때: OpenWakeWord로 "hey_jarvis" 감지
# 명령 모드일 때: Vosk로 "take off", "up" 등 인식 후 실행
if not is_command_mode:
    audio_np = np.frombuffer(data, dtype=np.int16)
    prediction = oww.predict(audio_np)
    if prediction[WAKE_WORD] > 0.5:
        print("[!] WAKE WORD DETECTED! Speak now...")
        is_command_mode = True
        v_rec.Reset()
else:
    if v_rec.AcceptWaveform(data):
        result = json.loads(v_rec.Result())
        cmd_text = result.get("text", "")
        if cmd_text:
            execute_command(cmd_text, drone)
            is_command_mode = False
            oww.reset()

실행 시 PC를 Tello Wi‑Fi(TELLO-XXXXXX)에 연결한 뒤 프로그램을 켠다. “Hey Jarvis”라고 부르고, 이어서 “Take off” 등을 말하면 드론이 반응한다.

6. 실습 3: PocketSphinx + Tello

PocketSphinx는 오프라인 인식이 가능한 클래식 엔진이다. 설치 시 Windows는 Visual C++ Build Tools, Mac은 Homebrew로 swig·portaudio 등을 설치해야 할 수 있다. SoundDevice로 일정 시간(예: 3.5초) 녹음한 뒤 SpeechRecognition 라이브러리로 PocketSphinx를 호출한다. 짧은 단어(“up” 등)보다 “go up”, “go down”, “take off”, “land”처럼 구문으로 매핑하면 인식률이 좋다.

PocketSphinx + SoundDevice — 녹음·인식 루프

DURATION = 3.5   # seconds
SAMPLE_RATE = 16000
r = sr.Recognizer()
while True:
    recording = sd.rec(int(DURATION * SAMPLE_RATE), samplerate=SAMPLE_RATE, channels=1, dtype='int16')
    sd.wait()
    audio_data = sr.AudioData(recording.tobytes(), SAMPLE_RATE, 2)
    try:
        command = r.recognize_sphinx(audio_data)
        execute_command(command)   # "take off", "go up", "land" 등 매핑
    except sr.UnknownValueError:
        pass

7. 실습 4: 데이터셋·CNN 학습·임베디드 추론

7-1. 데이터셋 준비

드론 명령어를 키워드/클래스로 구분해 학습하려면, 클래스별 폴더에 1초 길이 WAV(16kHz 또는 8kHz, 모노)를 넣는다. 예: takeoff, land, up, down, left, right, 배경 소음용 폴더 등. 직접 녹음하거나, Google Speech Commands v0.02를 받아 필요한 단어(on, up, down, left, right, off, 배경 소음 등)만 추출해 쓸 수 있다. UAV 명령용 데이터셋은 Command Dataset 링크에서 받을 수 있다. “Tello”처럼 공개 데이터셋에 없는 단어는 gTTS·pydub로 1초 WAV를 만들어 넣을 수 있다.

7-2. MFCC + 2D CNN 학습

librosa로 오디오에서 MFCC를 뽑고, 2D CNN(Conv2D + MaxPooling + Dense)으로 명령어를 분류한다. 샘플레이트(16kHz), 1초 길이, MFCC 개수(13) 등을 맞춰 두고, 클래스별 폴더를 돌며 로드한다. 배경 소음은 긴 파일을 1초 단위로 잘라 여러 샘플로 쓴다. 학습 후 모델을 저장하고, 정확도·F1·혼동 행렬·분류 리포트로 평가한다. 임베디드용으로 쓸 때는 8kHz·1초 raw 또는 MFCC로 입력을 맞춘 뒤 TFLite로 Full Integer 양자화해 내보내면 된다.

7-3. TFLite·라즈베리파이·M5Core2 요약

전체 흐름은 다음과 같다.

(1) Python: 8kHz·1초 raw 오디오를 입력으로 하는 1D CNN을 학습하고, TFLite Full Integer 양자화로 모델을 내보낸다.

(2) M5Core2(ESP32): 내보낸 모델을 C 배열로 변환해 TFLite Micro로 올리면, 보드 마이크로 1초 녹음 후 추론할 수 있다.

(3) 라즈베리파이 Zero 2 W: TFLite 런타임과 sounddevice로 8kHz·1초 캡처 후, 모델이 Int8 입력이면 Float32를 Int8로 바꿔 추론하고, 인식된 라벨에 따라 Tello 제어를 붙일 수 있다. 라즈베리파이에서 마이크가 안 잡히면 사용 중인 오디오 장치 번호를 확인한 뒤, 해당 장치를 지정해 녹음하면 된다.

8. 정리

이번 수업에서는 실시간 드론 제어에 적합한 오프라인 음성 인식을 다뤘다. Vosk는 지연이 적고 경량이라 “Stop” 같은 즉각 반응이 필요할 때 Whisper보다 유리하다. 마이크 입력은 PyAudio 대신 SoundDevice를 쓰면 Mac·Windows에서 같은 방식으로 동작한다. 실습 1에서는 Vosk만으로 Tello를 제어하고, 실습 2에서는 OpenWakeWord(“Hey Jarvis”)를 먼저 듣고 나서 Vosk로 명령을 받는 방식, 실습 3에서는 PocketSphinx와 SoundDevice로 고정 길이 녹음 후 인식하는 방식을 사용했다. 실습 4에서는 Google Speech Commands에서 필요한 단어만 추출·준비하고, Tello 등 커스텀 단어는 음성 합성으로 보강한 뒤, MFCC와 2D CNN으로 학습하고, TFLite로 내보내서 라즈베리파이·M5Core2 같은 보드에서 추론하는 흐름까지 정리했다.

[UNLV] - OpenCV와 YOLO: 컴퓨터 비전 실습(10일차)

빡성 — Thu, 19 Feb 2026 08:13:12 +0900

수업 개요
OpenCV 한눈에 보기
디지털 이미지와 필터링
엣지 검출부터 객체 인식까지
움직임 감지, 캘리브레이션, YOLO
실습 1: OpenCV 기초
실습 2: RPi 카메라 → PC 전송
실습 3: 캡처 도구와 YOLO 분석
실습 4: YOLO로 결과 다루기
정리

1. 수업 개요

이번 수업은 OpenCV와 YOLO로 컴퓨터 비전을 배우는 시간이었다. OpenCV는 카메라·이미지를 다루는 대표 라이브러리이고, YOLO는 영상 속에서 사물을 실시간으로 찾아 주는 AI 모델이다. 이론에서는 이미지가 어떻게 만들어지고, 노이즈를 줄이는 필터링, 경계선(엣지)을 뽑는 방법, 움직임 감지, YOLO의 특징까지 다뤘다. 실습에서는 Python으로 이미지 열기·색 보정·원 검출, 라즈베리파이 카메라에서 PC로 사진·영상 보내기, 웹캠으로 촬영한 뒤 YOLO로 검출·분류·세그멘테이션을 해 보며, 결과 데이터를 코드에서 어떻게 쓰는지까지 진행했다.

2. OpenCV 한눈에 보기

정의와 역사

OpenCV는 오픈소스 컴퓨터 비전·머신러닝 라이브러리다. 쉽게 말하면, 카메라·이미지를 읽고 처리하는 도구 모음이다. 실시간 컴퓨터 비전(real-time computer vision)에 맞춰 설계되어, 웹캠·드론·로봇처럼 “보는” 프로그램을 만들 때 표준으로 쓴다.

역사: 1999년 Intel에서 처음 개발했고, 2008년부터 개인용 로보틱스로 유명했던 Willow Garage가 지원했다. 이후 전 세계 커뮤니티가 유지·보수하며 지금까지 이어지고 있다.

플랫폼·라이선스·언어

플랫폼: Windows, Linux, Android, MacOS, iOS 등 주요 OS를 모두 지원하는 크로스 플랫폼이다. 한 번 배우면 여러 기기에서 쓸 수 있다.

라이선스: BSD 라이선스로 무료 제공되며, 상업적 용도로도 자유롭게 사용할 수 있다. 회사 제품에 넣어도 라이선스 비용이 들지 않는다.

기반 언어·API: 핵심은 C/C++로 작성되어 속도가 빠르다. 현재는 Python 바인딩이 가장 많이 쓰이고, Java, MATLAB도 지원한다. GPU 가속이 필요하면 NVIDIA CUDA, OpenCL 인터페이스를 쓸 수 있다. 슬라이드 기준 최신 안정 버전은 4.13.0으로 소개된 바 있다(실제 버전은 배포 시점에 따라 다를 수 있음).

알고리즘 개요

OpenCV에는 2,000개 이상의 알고리즘이 포함되어 있다. 주요 기능만 나열하면 다음과 같다.

일반 영상 처리, 이미지 피라미드(다중 해상도 표현)
세그멘테이션(영역 분할), 기하학적 기술자(Geometric descriptors)·특징점(Features) 추출
카메라 캘리브레이션, 스테레오·3D 비전
머신러닝(얼굴 검출, 객체 인식), 트래킹, 행렬 연산

딥러닝과의 관계: OpenCV는 단독으로도 쓰이지만, TensorFlow, PyTorch, Caffe, Keras 같은 딥러닝 프레임워크에서 이미지 전처리·로딩용으로 핵심적으로 사용된다. 즉, “영상 입력”을 다루는 단계에서 OpenCV가 자주 쓰인다.

주요 활용 분야

IT·서비스: 구글 맵, 스트리트 뷰, 구글 어스 등에서 이미지 처리에 사용된다.
안전·보안: 댐, 광산, 수영장 등의 안전 모니터링, 보안 시스템.
산업·연구: 학술·산업 연구, 공장 생산 라인의 머신 비전 검사 시스템.
엔터테인먼트·로봇: 영화 모션 캡처(Structure from Motion), 로보틱스 등 사실상 “눈”이 필요한 모든 분야에 쓰인다.

공식 리소스와 참고 문헌

공식 사이트: 문서·튜토리얼·예제는 docs.opencv.org, Q&A 포럼은 answers.opencv.org에서 이용할 수 있다. 공식 홈페이지 리소스 탭에서 책, 논문, 유용한 링크를 확인할 수 있다.

참고 문헌: 입문·실무용으로 OpenCV Essentials, OpenCV Starter, Learning Image Processing with OpenCV 등(Packt Publishing 위주)이 있다. 언어별로는 Python용 OpenCV Computer Vision with Python, Java용 OpenCV 3.0 Computer Vision with Java, .NET용 Emgu CV Essentials(C# 등)가 있고, 모바일·게임 쪽에서는 iOS/Android 전용 가이드, Raspberry Pi 활용, Unity 게임 엔진 연동을 다룬 서적도 있다.

주요 모듈 구성 (OpenCV Modules)

라이브러리는 기능별로 모듈이 나뉘어 있다. 필요한 기능만 골라 쓸 수 있다.

Core: 행렬 연산 및 기본 데이터 구조. 이미지가 숫자 배열로 어떻게 저장되는지 다룬다.
Imgproc: 이미지 필터링, 기하학적 변환 등 핵심 이미지 처리. 블러, 엣지, 형태학 연산 등이 여기 있다.
Highgui: 이미지·동영상 읽기/쓰기, 간단한 창(UI) 생성. imread, imshow 같은 함수가 여기 속한다.
Features2D: 특징점 검출 및 매칭. 다른 이미지 간에 같은 점을 찾을 때 쓴다.
Calib3d: 카메라 교정(캘리브레이션) 및 3D 재구성.
ML: 통계적 머신러닝(클러스터링, 부스팅, SVM 등). 딥러닝이 아닌 전통적인 ML 도구다.
Objdetect: 얼굴·물체 검출을 위한 미리 만들어진 검출기.

3. 디지털 이미지와 필터링

디지털 이미지 획득 (Digital Image Acquisition)

디지털 이미지가 만들어지는 물리적 과정을 단계별로 보면 다음과 같다. 카메라나 스캐너가 “보는” 방식을 이해하면, 왜 노이즈나 왜곡이 생기는지 파악하는 데 도움이 된다.

에너지원(Illumination source): 빛과 같은 에너지원이 있어야 한다. 어두우면 신호가 약해져 노이즈가 심해진다.
장면 요소(Scene element): 빛을 반사하거나 투과시키는 물체. 이게 우리가 찍는 “대상”이다.
이미징 시스템(Imaging system): 렌즈와 센서가 빛을 모아 전기 신호로 바꾼다.
이미지 평면 투영(Projection): 모인 빛이 카메라 내부의 이미지 평면에 맺힌다. 여기서 왜곡이 생길 수 있다.
디지털화(Digitized image): 연속적인 아날로그 신호를 격자 형태의 픽셀 데이터로 샘플링해 최종 이미지를 만든다.

디지털 카메라의 주요 문제점 (Digital Camera Issues)

위 과정에서 발생할 수 있는 기술적 결함이다. 알고 있으면 “왜 화질이 나쁜가”를 원인별로 이해할 수 있다.

노이즈(Noise): 저조도 환경에서 주로 발생한다. 감도(ISO)를 올리면 밝아지지만 노이즈도 함께 늘어난다.
색상 결함(Color): 베이어 패턴(Bayer pattern) 센서에서 나오는 색수차(Color fringing) — 경계 부근에서 색이 번져 보이는 현상.
블루밍(Blooming): 한 픽셀에 전하가 너무 많이 쌓이면 인접 픽셀로 넘쳐서 밝은 부분이 퍼져 보인다.
카메라 내부 처리(In-camera processing): 과도한 샤프닝(선명화)을 하면 물체 주변에 후광(Halo)이 생길 수 있다.
압축(Compression): JPEG 등으로 압축하면 블록 현상(Blocking artifacts) — 네모 칸이 보이는 현상이 나타날 수 있다.

이미지 필터링의 원리 (Image Filtering)

공간 필터링(Spatial filtering)은 “각 픽셀 값을 주변 픽셀과 일정한 규칙으로 계산해 바꾸는 것”이다. 이때 쓰는 규칙을 필터 마스크라고 부른다. 보통 3×3 크기 마스크를 많이 쓰며, 각 위치에 계수(가중치 w)를 두고 곱한 뒤 합산한다.

중간값 필터(Median Filter): 마스크 안의 픽셀 값들을 크기순으로 나열한 뒤, 그중 중간값을 선택해 해당 픽셀의 새 값으로 쓴다. 점처럼 튀는 노이즈(솔트-앤-페퍼)를 잘 제거하면서도 선이나 모서리는 비교적 잘 보존한다.

필터링 응용 예: 허블 망원경 이미지

실제 활용 예로 허블 망원경의 성단 이미지를 들 수 있다. 먼저 15×15 평균 마스크(Averaging mask)를 적용해 이미지를 부드럽게 만들고, 그다음 이진화(Thresholding) — 정해진 임계값을 기준으로 밝기를 잘라서 — 적용하면 주요 천체(객체)만 흰색으로 분리해 낼 수 있다.

노이즈 제거 성능 비교 (Filtering for Denoising)

솔트-앤-페퍼 노이즈를 제거할 때, 3×3 평균 필터를 쓰면 노이즈가 흐려지긴 하지만 잔상이 남고 디테일이 뭉개질 수 있다. 반면 3×3 중간값 필터는 노이즈를 거의 깔끔히 제거하면서도 회로 기판 같은 디테일을 잘 보존한다. 그래서 점 노이즈 제거에는 중간값 필터가 더 적합하다고 배우면 된다.

4. 엣지 검출부터 객체 인식까지

엣지 검출 (Edge Detection)

엣지 검출은 2D 이미지를 곡선의 집합으로 바꾸는 과정이다. 장면의 핵심적인 특징(Salient features)만 추출하므로, 원본 픽셀 데이터보다 훨씬 컴팩트한 정보로 압축된다. 즉, “경계선만 남긴 그림”을 만든다고 보면 된다.

최적의 엣지 검출: Canny 알고리즘

Canny가 제시한 “좋은 엣지 검출기”의 조건은 세 가지다.

좋은 검출(Good Detection): 노이즈가 아닌 실제 엣지에만 반응해야 한다. 거짓 양성을 줄이는 것.
좋은 위치 선정(Good Localization): 검출된 엣지가 실제 경계 위치와 매우 가깝게 나와야 한다.
단일 응답(Single Response): 하나의 엣지에는 선이 하나만 나와야 한다. 같은 경계가 두 줄로 나뉘어 나오면 안 된다.

참고로 스무딩(Smoothing)을 강하게 하면 노이즈는 줄어들어 검출이 좋아지지만, 경계 위치 정확도는 떨어지는 트레이드오프가 있다. 그래서 Canny에서는 이 둘을 절충한 파라미터를 쓰게 된다.

Canny 엣지 검출 단계: (1) 원본 이미지 → (2) 그래디언트 노름(Norm of gradient): 픽셀별 밝기 변화율을 계산 → (3) 임계값 적용(Thresholding): 유효한 엣지만 남기고 나머지 제거 → (4) 가늘게 만들기(Thinning): 엣지 두께를 1픽셀로 줄여 정교하게 만든다.

윤곽선 추출 예시 (Contours)

데이터 압축 측면에서 보면, 180,000개의 점으로 이루어진 이미지를 윤곽선 추출로 1,800개 미만으로 줄이고, 다시 근사화(Approximation)를 하면 180개 미만으로 비약적으로 줄일 수 있다. 복잡한 장면에서도 640×480 해상도 기준 약 70 FPS의 빠른 속도로 동작할 수 있다는 뜻이다.

객체 인식 (Object Recognition)

추출된 윤곽선(Contours)과 특징점 데이터를 기하학적으로 분석하면, 전화기, 신발, 곰인형 같은 특정 객체를 식별·분류할 수 있다. 이게 전통적인 컴퓨터 비전에서의 객체 인식 단계다. 최근에는 딥러닝(YOLO 등)으로 이 단계를 대체하는 경우가 많지만, 원리를 이해하려면 윤곽선·특징점이 어떻게 쓰이는지 알아두는 것이 좋다.

5. 움직임 감지, 캘리브레이션, YOLO

인간 포즈·수어 추정 (Human Pose / Sign Estimation)

이미지로부터 사람의 관절 위치나 손동작(수어)을 파악하는 기술이다. OpenCV·관련 라이브러리에서는 보통 다음 세 가지 정보를 활용한다.

Depth(깊이): 8UC1 형식의 깊이 데이터로 손·몸의 형태를 파악한다. 카메라로부터의 거리 정보가 있으면 2D보다 정확한 포즈 추정이 가능하다.
Label(라벨링): 손가락 마디, 손바닥 등 각 부분을 색상 코드로 구분해 세그멘테이션한다. “어디가 손가락인지” 영역별로 표시하는 단계다.
Model(모델링): 추정된 데이터를 실제 3D 손·몸 모델과 매칭해 실시간 포즈를 재구성한다.

움직임 감지 기법 (Motion Detection)

영상 안에서 “움직이는 객체”를 찾아내는 대표적인 방법 세 가지다.

프레임 차이법(Frame Differencing): 현재 프레임에서 이전 프레임을 빼는 방식이다. 수식으로는 |Frame_t − Frame_{t−1}|. 구현이 매우 빠르고 간단하지만, 노이즈에 취약하고 객체가 멈추면 차이가 0이 되어 감지하지 못한다.
배경 차분법(Background Subtraction): 시간에 따라 “움직이지 않는 배경” 모델을 학습해 두고, 현재 프레임에서 배경을 빼서 움직이는 전경(Foreground)만 분리한다. 조명 변화나 그림자에 상대적으로 강하다.
광학 흐름(Optical Flow): 영상의 각 픽셀에 대해 “속도와 방향 벡터”를 계산하는 고급 기법이다. 데이터는 풍부하지만 연산 비용이 크다. 흐름을 조금만 쓰고 싶을 때는 희소(Sparse) 광학 흐름, 전체 픽셀을 쓰면 밀집(Dense) 광학 흐름이라고 부른다.

광학 흐름의 원리: “같은 점의 밝기는 시간이 조금 지나도 변하지 않는다”는 가정(밝기 불변성)을 쓴다. 수식으로는 I(x+dx, y+dy, t+dt) = I(x, y, t). OpenCV에서는 희소 광학 흐름에 calcOpticalFlowPyrLK(), 밀집 광학 흐름에 calcOpticalFlowFarneback()를 주로 사용한다.

단일 카메라 캘리브레이션 (Single Camera Calibration)

렌즈의 왜곡을 보정하고 카메라의 내부·외부 특성을 파악하는 과정이다. 체커보드(Checkerboard)를 카메라 앞에 몇 초간 들고 있는 것만으로 보정에 필요한 점들을 자동으로 찾을 수 있다. 결과로 카메라의 내부/외부 파라미터를 계산하고, 왜곡된 이미지를 평평하게 보정한 Un-distorted image를 얻을 수 있으며, 이를 바탕으로 3D 뷰·측정을 할 수 있다.

OpenCV 머신러닝 라이브러리 (MLL)

OpenCV 내부에 들어 있는 전통적인 머신러닝 도구들이다. 딥러닝이 아닌, 통계·기하 기반 ML이다.

분류·회귀: FLANN, Random Trees, SVM, Naive Bayes, MLP(역전파), Boosting 등.
클러스터링: K-Means, EM(Expectation-Maximization) 알고리즘.
검증: 교차 검증(Cross validation), 부트스트래핑(Bootstrapping) 등 성능 평가·튜닝에 쓰인다.

YOLO: 정의·발전·장단점·활용

YOLO는 “You Only Look Once”의 약자로, 현재 가장 널리 쓰이는 실시간 객체 인식 시스템이다. 이미지를 여러 단계로 스캔하는 기존 방식과 달리, 객체 검출을 단일 회귀 문제(Single regression problem)로 취급한다. 즉, 이미지를 딱 한 번만 보고 “무엇이 있는지(Classification)”와 “어디에 있는지(Bounding Boxes)”를 동시에 예측한다. 추론 속도가 매우 빨라 실시간 영상 처리의 표준으로 자리 잡았다.

YOLO의 발전 과정 (Evolution of YOLO): v1(2015)은 실시간 인식을 가능하게 한 돌파구였으나 작은 객체 인식에 취약했다. v2·v3에서는 앵커 박스(Anchor Boxes)와 다중 스케일 검출을 도입해 성능을 개선했다. v4·v5에서는 모자이크 증강(Mosaic augmentation) 등 속도 최적화와 PyTorch 구현에 집중했다. v8(2023) 이후는 앵커 프리(Anchor-Free) 방식과 포즈 추정, 세그멘테이션 기능을 공식 지원하며 현재의 표준이 되었다.

장점: 현대 GPU에서 140 FPS 이상의 속도, 이미지 전체를 한꺼번에 보기 때문에 배경을 객체로 오인하는 오류가 적고, 검출·세그멘테이션·포즈 등 다양한 API를 한 번에 지원한다. 단점: 새 떼처럼 작고 빽빽하게 모여 있는 객체를 구분할 때는 Faster R-CNN 같은 2단계 검출기보다 다소 약할 수 있다.

실생활 활용 사례 (YOLO Real-World Applications): 자율 주행에서 보행자·신호등을 밀리초 단위로 감지하고, 보안·감시에서 침입자 감지·군중 밀집도 계산에 쓰인다. 리테일 자동 계산, 의료 영상의 종양 감지, 드론을 이용한 농작물 모니터링 등 광범위하게 활용된다.

6. 실습 1: OpenCV 기초

여기서는 OpenCV로 이미지를 열고, 색을 보정해서 보여 주고, 원을 찾아 그리는 것까지 해 본다. 먼저 pip install opencv-python matplotlib numpy로 라이브러리를 설치한 뒤 진행하면 된다.

6-1. 이미지 로드와 검사

OpenCV는 이미지를 NumPy 배열로 읽는다. 그래서 shape, dtype 같은 배열 속성으로 크기·채널·픽셀 타입을 바로 확인할 수 있다. 컬러 이미지는 3차원(높이, 너비, 채널), 그레이스케일은 2차원이다. shapes.png가 있는 폴더에서 아래 스크립트를 실행해 보자.

이미지 로드 및 검사 (inspect_image.py)

import cv2 as cv
image_path = "shapes.png"
img = cv.imread(image_path, cv.IMREAD_COLOR)
if img is None:
    print(f"Error: Could not load image from {image_path}")
else:
    print(f"Data Type: {type(img)}")       # <class 'numpy.ndarray'>
    print(f"Dimensions: {img.ndim}")       # 3 for color images
    print(f"Shape: {img.shape}")           # (Height, Width, Channels)
    print(f"Pixel Data Type: {img.dtype}") # uint8
    img_gray = cv.imread(image_path, cv.IMREAD_GRAYSCALE)
    print(f"Grayscale Shape: {img_gray.shape}")  # (Height, Width)

6-2. 시각화와 BGR → RGB 변환

OpenCV는 이미지를 BGR(파랑·초록·빨강) 순으로 읽는다. Matplotlib·화면은 보통 RGB(빨강·초록·파랑)라서, 그대로 넣으면 색이 반대로 보인다. cv.cvtColor(image, cv.COLOR_BGR2RGB)로 바꾼 뒤 표시하고, 그레이스케일은 cmap='gray'로 보여 주면 된다.

시각화 및 색공간 변환 (display_image.py)

import cv2 as cv
from matplotlib import pyplot as plt

def show_image(image, title="Image", is_bgr=True):
    if is_bgr:
        image = cv.cvtColor(image, cv.COLOR_BGR2RGB)
    plt.imshow(image)
    plt.title(title)
    plt.xticks([]), plt.yticks([])
    plt.show()

if __name__ == "__main__":
    img = cv.imread("shapes.png", cv.IMREAD_COLOR)
    if img is not None:
        show_image(img, title="Corrected RGB Output")
        img_gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
        plt.imshow(img_gray, cmap='gray')
        plt.title("Grayscale Version")
        plt.xticks([]), plt.yticks([])
        plt.show()
    else:
        print("Image not found.")

6-3. 원 검출 (Canny + Hough)

도형을 찾는 흐름은 (1) 그레이스케일로 바꾸고, (2) Canny로 엣지를 뽑고, (3) Hough 변환으로 원을 찾는 것이다. Canny 50·150은 약한/강한 엣지 구분, HoughCircles의 minDist·minRadius·maxRadius로 원 크기·간격을 조절한다. smarties.png로 실행하면 검출된 원이 초록색으로 그려진다.

원 검출 (detect_circles.py)

def detect_and_draw_circles(image_path):
    img = cv.imread(image_path)
    if img is None: return
    img_gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
    edges = cv.Canny(img_gray, 50, 150)
    circles = cv.HoughCircles(edges, cv.HOUGH_GRADIENT, dp=1, minDist=20,
                              param1=50, param2=30, minRadius=10, maxRadius=50)
    output_img = img.copy()
    if circles is not None:
        circles = np.uint16(np.around(circles))
        for i in circles[0, :]:
            cv.circle(output_img, (i[0], i[1]), i[2], (0, 255, 0), 5)
            cv.putText(output_img, "Circle", (i[0]-30, i[1]), cv.FONT_HERSHEY_COMPLEX, 0.5, (0,0,0))
    output_img_rgb = cv.cvtColor(output_img, cv.COLOR_BGR2RGB)
    plt.figure(figsize=(10, 5))
    plt.imshow(output_img_rgb)
    plt.title(f"Detected {len(circles[0])} Circles")
    plt.xticks([]), plt.yticks([])
    plt.show()
detect_and_draw_circles("smarties.png")

7. 실습 2: RPi 카메라 → PC 전송

라즈베리파이 Zero W2에 CSI 카메라를 붙이고, PC로 사진 한 장 보내기·실시간 영상 보내기를 해 본다. RPi와 PC는 같은 Wi-Fi에 있어야 하고, Bookworm OS에서는 예전 raspistill 대신 rpicam-apps, Picamera2를 쓴다.

7-1. RPi 환경 설정 (스왑·의존성)

설치 중 메모리 부족으로 멈추지 않도록, 먼저 스왑을 2GB로 늘려 두자. sudo nano /etc/dphys-swapfile에서 CONF_SWAPSIZE=100을 CONF_SWAPSIZE=2048로 바꾼 뒤 저장하고, sudo dphys-swapfile setup, sudo dphys-swapfile swapon으로 적용한다. RPi 쪽 패키지: sudo apt update, sudo apt install rpicam-apps python3-libcamera python3-kms++ libcamera-ipa python3-picamera2. PC에는 VLC와 pip install opencv-python ultralytics numpy가 필요하다. Windows에서 netcat이 필요하면 Nmap 설치 시 Ncat을 선택해 두면 ncat 명령을 쓸 수 있다.

7-2. 단일 이미지 전송

CLI 방식: PC에서 먼저 nc -l 5000 > received_image.jpg(Mac)로 대기. RPi에서 rpicam-jpeg -o - -t 2000 --width 1920 --height 1080 | nc PC_IP 5000 실행하면 한 장이 전송된다. Python 방식: RPi에서 Picamera2로 JPEG 캡처 후 TCP로 보내고, PC에서 소켓으로 받아 파일로 저장한다. HOST_IP·PORT(65432)만 본인 환경에 맞게 바꾸면 된다.

RPi 송신 (send_image.py)

import socket, time
from picamera2 import Picamera2
HOST_IP = '192.168.1.10'  # 호스트 PC IP로 변경
PORT = 65432
picam2 = Picamera2()
config = picam2.create_preview_configuration(main={"size": (1920, 1080), "format": "XRGB8888"})
picam2.configure(config)
picam2.start()
time.sleep(2)
jpg_data = picam2.capture_buffer("main", format="jpeg")
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST_IP, PORT))
    s.sendall(jpg_data)
    print("Image sent!")
picam2.stop()

호스트 수신 (recv_image.py)

import socket
PORT = 65432
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind(('0.0.0.0', PORT))
    s.listen()
    print("Waiting for image...")
    conn, addr = s.accept()
    with conn:
        with open('received_py.jpg', 'wb') as f:
            while True:
                data = conn.recv(4096)
                if not data: break
                f.write(data)
    print("Image saved as received_py.jpg")

7-3. 영상 스트리밍

VLC로 보기: RPi에서 rpicam-vid -t 0 --inline --listen -o tcp://0.0.0.0:8554 --width 1280 --height 720 --framerate 30 실행. PC의 VLC에서 File → Open Network, URL에 tcp/h264://RPI_IP:8554 입력하면 실시간 영상이 보인다.

Python으로 받아서 OpenCV·YOLO 쓰기: raw H.264는 OpenCV에서 까다로울 수 있어서, 프레임마다 JPEG로 압축해 보내는 MJPEG 스타일이 편하다. 형식은 [4바이트 길이][JPEG 데이터]. RPi는 계속 캡처해서 길이+데이터를 보내고, PC는 길이만큼 읽어 cv2.imdecode로 프레임 복원 후 화면에 띄우거나 YOLO에 넣으면 된다. 실행 순서: PC(수신)를 먼저 켜고, 그다음 RPi(송신)를 실행한다.

RPi 스트리밍 송신 (rpi_stream_sender.py)

import socket, struct, io
from picamera2 import Picamera2
HOST_IP, PORT = '192.168.1.10', 8000
picam2 = Picamera2()
config = picam2.create_preview_configuration(main={"size": (640, 480), "format": "XRGB8888"})
picam2.configure(config)
picam2.start()
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((HOST_IP, PORT))
connection = client_socket.makefile('wb')
try:
    while True:
        stream = io.BytesIO()
        picam2.capture_file(stream, format="jpeg")
        data = stream.getvalue()
        connection.write(struct.pack('<L', len(data)))
        connection.write(data)
except KeyboardInterrupt: pass
finally:
    connection.close(); client_socket.close(); picam2.stop()

호스트: OpenCV 그레이 표시 (host_stream_opencv_view.py)

import socket, struct, cv2, numpy as np, io
PORT = 8000
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('0.0.0.0', PORT))
server_socket.listen(0)
conn, addr = server_socket.accept()
connection = conn.makefile('rb')
while True:
    image_len_data = connection.read(4)
    if not image_len_data: break
    image_len = struct.unpack('<L', image_len_data)[0]
    image_stream = io.BytesIO()
    image_stream.write(connection.read(image_len))
    image_stream.seek(0)
    data = np.frombuffer(image_stream.getvalue(), dtype=np.uint8)
    frame = cv2.imdecode(data, cv2.IMREAD_COLOR)
    if frame is not None:
        gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        cv2.imshow('RPi Stream (Gray)', gray_frame)
    if cv2.waitKey(1) & 0xFF == ord('q'): break
conn.close(); server_socket.close(); cv2.destroyAllWindows()

호스트: YOLO 검출 (host_stream_yolo_detect.py)

from ultralytics import YOLO
model = YOLO("yolov8n.pt")
# 위와 동일하게 image_len 읽기, frame = cv2.imdecode(...) 후
# results = model(frame, verbose=False)
# annotated_frame = results[0].plot()
# cv2.imshow('YOLOv8 Detection', annotated_frame)

8. 실습 3: 캡처 도구와 YOLO 분석

웹캠으로 사진·영상을 찍고, 그걸 YOLO로 검출·분류·세그멘테이션해 보는 단계다. 먼저 캡처 도구로 데이터를 모은 뒤, 분석 스크립트에서 불러와서 쓴다.

8-1. 캡처 도구 (01_capture_tool.py)

웹캠을 켜고 키보드로 조작한다. i 한 장 저장, v 녹화 시작/중지, q 종료. 파일명은 capture_타임스탬프.jpg, video_타임스탬프.mp4처럼 저장된다. 녹화 중일 때는 화면 왼쪽 위에 빨간 점이 보인다. i로 사진 몇 장, v로 짧은 영상 한 번씩 찍어 두면 다음 단계에서 쓸 수 있다.

캡처 도구 (01_capture_tool.py) — 키 처리

cap = cv2.VideoCapture(0)
writer = None
recording = False
# CONTROLS: 'i'=Image, 'v'=Video toggle, 'q'=Quit
while True:
    ret, frame = cap.read()
    if recording:
        cv2.circle(display_frame, (30, 30), 10, (0, 0, 255), -1)
        writer.write(frame)
    cv2.imshow("Webcam Capture Tool", display_frame)
    key = cv2.waitKey(1) & 0xFF
    if key == ord('i'):
        cv2.imwrite(f"capture_{int(time.time())}.jpg", frame)
    elif key == ord('v'):
        if not recording:
            writer = cv2.VideoWriter(filename, cv2.VideoWriter_fourcc(*'mp4v'), 30, (width, height))
            recording = True
        else:
            writer.release()
            recording = False
    elif key == ord('q'):
        break

8-2. YOLO 분석 (02_analyze_media.py)

SOURCE는 입력 소스다. 0이면 웹캠, 파일명(예: capture_12345.jpg, video_12345.mp4)을 넣으면 그 파일을 연다. TASK를 'detect', 'classify', 'segment' 중 하나로 바꾸면 된다. detect → yolov8n.pt, classify → yolov8n-cls.pt, segment → yolov8n-seg.pt가 자동 선택된다. 이미지면 한 번 추론 후 화면에 띄우고 끝나고, 비디오/웹캠이면 프레임마다 추론해서 보여 준다.

모드별로 보이는 것: (A) detect — 박스와 라벨(예: Person 0.85, Cell Phone). (B) classify — 박스 없이 상위 클래스만(예: coffee_mug 0.70). ImageNet 1000클래스 기준. (C) segment — 객체를 반투명 색으로 픽셀 단위로 칠해서 구분. 첫 실행 시 모델 파일이 자동 다운로드된다. Nano(yolov8n.pt)는 작고 빠르서 CPU에서도 돌리기 좋다.

02_analyze_media.py — TASK·모델 선택

SOURCE = 0   # or 'capture_12345.jpg' / 'video_12345.mp4'
TASK = 'segment'  # 'detect' | 'classify' | 'segment'
if TASK == 'detect':   model = YOLO('yolov8n.pt')
elif TASK == 'classify': model = YOLO('yolov8n-cls.pt')
elif TASK == 'segment': model = YOLO('yolov8n-seg.pt')
# 이미지면: results = model(SOURCE); res_plotted = results[0].plot(); cv2.imshow(...); cv2.waitKey(0)
# 비디오/웹캠이면: cap = cv2.VideoCapture(SOURCE); 루프에서 model(frame, verbose=False); results[0].plot()

9. 실습 4: YOLO로 결과 다루기

YOLO로 정적 이미지·웹캠 영상을 분석하고, 화면에 그리는 것 말고 코드에서 결과를 어떻게 쓰는지까지 다룬다. "사람이 보이면 드론 멈추기" 같은 로직을 만들 때 필요하다.

9-1. 정적 이미지 검출 (yolo_image.py)

COCO 80클래스(사람, 자동차, 개, 휴대폰 등)로 학습된 모델을 불러와서, 로컬 파일이나 URL 이미지에 추론한다. results는 리스트라서 for result in results로 돌리며 result.plot()으로 그린 뒤 창에 띄우고, 키 입력 시 종료하면 된다.

yolo_image.py — 정적 이미지 검출

from ultralytics import YOLO
import cv2
model = YOLO('yolov8n.pt')
image_source = 'https://ultralytics.com/images/zidane.jpg'  # or local path
results = model(image_source)
for result in results:
    annotated_frame = result.plot()
    cv2.imshow("YOLO Detection", annotated_frame)
    cv2.waitKey(0)
cv2.destroyAllWindows()

9-2. 웹캠 실시간 검출 (yolo_webcam.py)

웹캠을 열고 매 프레임을 YOLO에 넣어서 박스·라벨을 그린 뒤 화면에 띄운다. stream=True로 두면 비디오에서 메모리 관리가 수월하다. q를 누르면 종료. 드론·로봇에서 실시간 영상 검출할 때와 같은 패턴이다.

yolo_webcam.py — 웹캠 실시간 검출

cap = cv2.VideoCapture(0)
while True:
    success, frame = cap.read()
    if not success: break
    results = model(frame, stream=True)
    for result in results:
        annotated_frame = result.plot()
        cv2.imshow("YOLO Real-Time Inference", annotated_frame)
    if cv2.waitKey(1) & 0xFF == ord('q'): break
cap.release()
cv2.destroyAllWindows()

9-3. 결과 데이터 활용 (boxes, conf, cls, name)

"사람이 감지되면 드론 정지"처럼 로직을 넣으려면, 그리기(plot)가 아니라 숫자 데이터를 써야 한다. result.boxes에서 각 박스마다 xyxy[0](x1,y1,x2,y2), conf[0](신뢰도 0~1), cls[0](클래스 번호), model.names[cls](클래스 이름)을 꺼낸다. 예: name == 'person'이고 conf > 0.5일 때만 동작하도록 조건을 걸 수 있다.

결과에서 좌표·클래스·신뢰도 추출

for result in results:
    boxes = result.boxes
    for box in boxes:
        x1, y1, x2, y2 = box.xyxy[0]
        conf = box.conf[0]
        cls = int(box.cls[0])
        name = model.names[cls]
        if name == 'person' and conf > 0.5:
            print(f"Person detected at [{x1}, {y1}] with {conf:.2f} confidence")

10. 정리

이번 수업에서는 OpenCV의 정의·역사·플랫폼·라이선스, 기반 언어·API·알고리즘 개요(2,000개 이상)·딥러닝과의 관계, 주요 활용 분야(IT·안전·산업·엔터테인먼트), 공식 리소스·참고 문헌, 주요 모듈(Core, Imgproc, Highgui, Features2D, Calib3d, ML, Objdetect)을 정리했다. 이어서 디지털 이미지 획득 5단계, 디지털 카메라의 5가지 문제점(노이즈·색수차·블루밍·후광·압축), 이미지 필터링 원리(공간 필터링·마스크·중간값 필터)·허블 망원경 예·노이즈 제거 비교, 엣지 검출·Canny 세 조건·4단계·스무딩 트레이드오프, 윤곽선 추출(데이터 압축·70 FPS)·객체 인식, 인간 포즈·수어 추정(Depth·Label·Model), 움직임 감지 세 가지(프레임 차이·배경 차분·광학 흐름)·밝기 불변성·calcOpticalFlowPyrLK/Farneback, 캘리브레이션(체커보드·Un-distorted image)·OpenCV ML(분류·클러스터링·검증), YOLO 정의·발전(v1~v8)·장단점·실생활 활용을 다뤘다.

실습은 네 묶음으로 진행했다. 실습 1 OpenCV 기초(설치·이미지 로드·검사·BGR→RGB·원 검출), 실습 2 RPi 카메라에서 PC로(환경 설정·스왑·단일 이미지·스트리밍 VLC·Python MJPEG), 실습 3 캡처 도구와 YOLO 분석(01_capture_tool·02_analyze_media detect/classify/segment), 실습 4 YOLO 정적 이미지·웹캠 실시간·결과 데이터(boxes, conf, cls, name) 활용이다. 드론·로봇·감시 등 실시간 비전 파이프라인과 데이터 활용의 기초가 되는 내용이다.

[UNLV] - 모델 압축과 TinyML 배포(9일차)

빡성 — Thu, 19 Feb 2026 02:57:11 +0900

수업 개요
이식성 트레이드오프 (Portability Trade-offs)
ML 모델 진화: 정확도 vs 연산량
대표 CNN 모델 비교
모델 압축 기법의 위치
Tiny 디바이스 최적화 3대 축
Pruning (가지치기)
Quantization (양자화)
Knowledge Distillation (지식 증류)
TinyML과 M5Core2 배포 워크플로우
실습 Task I: IMU 데이터 전송 방식 비교
실습 Task II·III: CNN 압축과 보드 추론
정리

1. 수업 개요

이번 수업은 임베디드/하드웨어 환경에서의 이식성(Portability)과 효율(Efficiency)의 트레이드오프, 그리고 모델 압축(Quantization, Pruning, Knowledge Distillation)을 통해 Tiny 디바이스에 ML 모델을 배포하는 전 과정을 다뤘다.

큰 모델과 범용 코드의 "이식성"을 고집하면 비용·전력·엔지니어링 노력이 커질 수 있고, 반대로 HW 맞춤 최적화를 하면 이식성은 떨어지는 선택이 자주 필요하다. 임베디드에서는 정확도뿐 아니라 연산량·지연·전력·메모리를 함께 고려해야 한다.

실습에서는 M5Core2에서 PC로 IMU 데이터를 전송하는 방식(BLE, WiFi UDP, ESP-NOW)을 비교하고, CNN 모델에 프루닝과 양자화를 적용해 TFLite로 변환한 뒤 M5Core2에 배포하는 파이프라인을 경험했다.

2. 이식성 트레이드오프 (Portability Trade-offs)

임베디드에서는 "이식성을 희생하고 효율을 얻는" 선택이 자주 필요하다. 특정 HW(보드) 구현 관점에서 선택지는 크게 두 가지다.

Option 1: 범용 코드 이식성/호환성(Universal Code Portability)을 최우선으로 할 때

장점: 여러 시스템에서 그대로 동작한다(이식성 ✓).
단점: 비용(Cost), 전력(Power), 엔지니어링 노력(Engineering Effort)이 커질 수 있다(✗).

Option 2: 이식성은 낮추고(Lower Code Portability) 최적화할 때

단점: 이식성이 떨어진다(✗).
장점: 비용/전력/개발 노력 측면에서 유리하다(✓).

핵심은 "어디서나 동일하게 동작"을 고집하면 비용·전력·노력에서 불리해질 수 있고, HW 맞춤 최적화를 하면 이식성은 떨어질 수 있다는 트레이드오프를 인지하는 것이다.

3. ML 모델 진화: 정확도 vs 연산량

모델이 발전할수록 정확도(Top-1 Accuracy)를 올리기 위해 연산량(GFLOPs)과 규모가 커지는 경향이 있다. 동시에 모바일/엣지 지향 모델(예: MobileNet 계열)처럼 연산량 대비 효율을 노린 모델도 등장한다.

임베디드에서는 "정확도만"이 아니라 연산량·지연·전력·메모리까지 함께 봐야 한다. 작은 모델은 더 빠르게 돌고, 메모리를 덜 쓰며, 전력을 덜 소비한다(Smaller models run faster, use less memory, and consume less power).

4. 대표 CNN 모델 비교

대표 CNN들을 정확도·파라미터 규모·특징으로 비교하면 다음과 같다.

AlexNet (2012): Top-1 약 63%(ImageNet), 약 60M parameters, 수백 MB 수준. 초기 딥 CNN의 대표로, 현재는 교육/학습용 성격.
VGGNet (VGG16/19): VGG16 Top-1 약 71.3%, 약 138M params, 약 528MB. 구조가 단순하고 균일하지만 크고 무거움(heavy compute).
ResNet (ResNet152V2 등): Top-1 약 78.0%, 약 60.4M params. Residual 구조로 성능이 좋고, VGG보다 효율적인 경향.
MobileNet (MobileNetV3 Large): Top-1 약 75.2%, 약 5.48M params. 모바일/엣지용으로 크기와 지연(latency)에서 유리한 트레이드오프.

임베디드/엣지에서는 MobileNet처럼 "작고 효율적인 모델"이 중요하다.

5. 모델 압축 기법의 위치

ML 시스템을 (1) Models ↔ (2) Runtimes ↔ (3) Hardware 세 층으로 보면, 서로 영향을 주는 생태계다. "하드웨어에 맞게 실제로 돌아가게" 하려면 모델 자체뿐 아니라 런타임과 하드웨어까지 포함한 최적화가 필요하다.

Model Compression Techniques로는 Pruning(가지치기), Quantization(양자화), Knowledge Distillation(지식 증류) 등이 있다. 이 기법들을 조합(Quantized & pruned, Distillation applied)하여 사용할 수 있다.

6. Tiny 디바이스 최적화 3대 축

Tiny 디바이스에서 모델을 맞추기 위한 대표 기법 세 가지는 다음과 같다.

Quantization(양자화): float32 → int8처럼 정밀도를 낮춰(정수화) 모델을 가볍게 한다.
Model Pruning(프루닝): 중요하지 않은 뉴런/연결을 제거한다.
Knowledge Distillation(지식 증류): 큰(teacher) 모델의 지식을 작은(student) 모델이 모방하도록 학습시킨다.

이를 묶어 Model Compression(모델 압축)으로 사용하며, "Quantized & pruned", "Distillation applied"처럼 조합 가능하다.

7. Pruning (가지치기)

Pruning은 자원 제약 장치에서 실시간 추론에 적합하도록 모델을 최적화하는 압축 기법이다. 촘촘한 연결(가중치/시냅스) 중 일부를 제거하는 방식으로 이해할 수 있다.

Pruning은 두 관점으로 설명할 수 있다.

Synapse(가중치 연결) 제거: 특정 가중치를 0으로 만들어 연결 자체를 줄인다.
Neuron(노드) 제거: 뉴런 전체를 제거하여 연산과 파라미터를 줄인다.

tensorflow-model-optimization 패키지로 프루닝을 적용할 수 있고, 설치가 어려우면 수동(manual) 프루닝도 가능하다. 압축률(compression %)을 계산하여 보고하는 것이 실습 목표 중 하나다.

8. Quantization (양자화)

Quantization은 모델 파라미터(기본 float32)를 정밀도가 낮은 표현으로 바꾸는 최적화다. 결과적으로 모델 크기 감소, 이식성 향상, 계산 속도 향상이 기대된다.

분류: PTQ vs QAT

Post-training Quantization (PTQ): 학습이 끝난 모델을 변환(conversion)해서 양자화한다. POT(Post-training Optimization Tool) 같은 도구가 빠르고 쉽다. 모델 사이즈 감소와 CPU/하드웨어 가속기 지연 개선 효과가 있으나, 정확도 저하가 조금 있을 수 있다(little degradation).
Quantization-aware Training (QAT): 학습 단계에서 추론 시 양자화를 에뮬레이션(emulates inference-time quantization)한다. 실제 양자화 모델을 만들 때 양자화 환경을 고려한 모델이 되도록 한다. 8-bit 같은 저정밀 사용이 배포 시 이점을 만든다.

왜 되는가? AlexNet 예시처럼 가중치 분포가 좁은 범위에 몰려 있는 경향이 있어, 큰 손실 없이 더 적은 비트로 표현 가능하다. 양자화 대상은 Weights(가중치), Biases(바이어스), Activations(활성값)이다. 연속적인 분포(실수)를 이산적인 값(계단/막대 형태)으로 바꾸는 과정이다.

9. Knowledge Distillation (지식 증류)

지식 증류는 "큰 모델의 지식을 작은 모델로 옮기는 과정"이다. 큰 네트워크(teacher) → 작은 네트워크(student) 구조로, 같은 입력 x가 teacher와 student에 동시에 들어간다.

Teacher 출력은 Softmax(T=t) 형태로 soft labels(부드러운 확률 분포)를 생성하고, student도 Softmax(T=t)로 soft predictions를 만든다. teacher soft label과 student soft prediction 사이를 맞추는 distillation loss를 계산한다. 동시에 student는 Softmax(T=1)에서 실제 정답 y(ground truth, hard label)와의 차이를 student loss로 학습한다.

핵심은 "정답만" 따라가는 것이 아니라, teacher가 내는 클래스 확률분포 전체(soft target)를 참고해 더 풍부한 정보를 학습한다는 점이다.

10. TinyML과 M5Core2 배포 워크플로우

TinyML/Embedded ML은 wearable, camera, IoT sensor 같은 작고 저전력 장치에서 동작한다. MCU 예시로 메모리 16KB, 32-bit Arm Cortex-M4 같은 제한이 강조된다. 따라서 "Shrink & Fit Model into Small Memory"가 핵심이고, Model Shrinking Concepts로 Quantization(32bits→8bits), Model Pruning, Distillation/Knowledge Distillation, Model Compression 등이 정리된다.

Audio ML Workflow: TFLite Model to Arduino (M5Core2) 흐름은 대략 다음과 같다.

PC에서 모델 학습: TensorFlow로 학습하고 model.tflite 출력.
INT8로 양자화: 컨트롤러에서 돌아가도록 사이즈 축소.
TFLite → C 배열로 변환: xxd -i model_int8.tflite > model_data.cc 같은 형태로 C/C++ 배열화.
Arduino Sketch(M5Core2) 구성: model_data.cc 추가, 메모리(arena) 설정, TFLM(TensorFlow Lite Micro) 라이브러리, 특징추출(MFCC), 추론 루프(inference loop).
오디오 캡처 & 특징 추출: 마이크(i2s, 16kHz), log-mel / MFCC(40). 학습 때와 동일한 설정 유지가 중요하다.
TFLite Micro로 추론: 루프에서 실행, MFCC 특징 입력, 출력 점수/라벨 읽기.
M5Core2에 최종 배포: C array 모델, INT8 양자화, 업로드 및 실행.

11. 실습 Task I: IMU 데이터 전송 방식 비교

PC로 IMU 데이터를 캡처할 때 다음 세 가지 프로토콜을 각각 테스트했다. 어떤 것이 더 빠른지, 얼마나 빠른지(속도 측정), 각 프로토콜이 어떻게 동작하는지(작동 원리)를 비교하는 것이 목표다.

① BLE (Bluetooth Serial)

M5Core2에서 BluetoothSerial로 "M5Core2_IMU" 이름으로 BLE를 초기화하고, 50Hz(20ms 간격)로 가속도·자이로(ax, ay, az, gx, gy, gz)를 타임스탬프와 함께 한 줄씩 전송한다. PC에서는 페어링 후 해당 COM 포트를 열어 시리얼로 수신하고, CSV로 저장한 뒤 pandas로 시각화한다.

M5Core2 BLE 전송 (M5Core2_BTSerial.ino)

SerialBT.begin("M5Core2_IMU");
// 50Hz: interval 20000 us
SerialBT.printf("%lu,%.3f,%.3f,%.3f,%.3f,%.3f,%.3f\n", 
                millis(), ax, ay, az, gx, gy, gz);

Python BLE 수신 및 로깅 (M5Core2_BTSerial_capture.py)

ser = serial.Serial(port, BAUD, timeout=1)
while (time.time() - start_time) < RECORD_SECONDS:
    if ser.in_waiting > 0:
        line = ser.readline().decode('utf-8', errors='ignore').strip()
        parts = line.split(',')
        if len(parts) == 7:  # ms, ax, ay, az, gx, gy, gz
            data_list.append(parts)
df.to_csv(OUT_FILE, index=False)  # bt_imu_log.csv

② WiFi: UDP

M5Core2는 WiFi에 연결한 뒤, IMU에서 가속도·자이로를 읽고 온보드에서 쿼터니언을 계산(자이로 적분 + 가속도 보정)한다. 계산된 qw, qx, qy, qz를 UDP 패킷으로 PC IP와 포트(예: 12345)로 전송한다. PC에서는 UDP 소켓을 열고 해당 포트에서 수신한 패킷을 파싱해 quaternion_wifi_log.csv로 저장하고 시각화한다.

M5Core2 UDP 전송 (M5Core2_UDP_TX.ino)

udp.beginPacket(host_ip, udp_port);
udp.printf("%lu,%.4f,%.4f,%.4f,%.4f", millis(), qw, qx, qy, qz);
udp.endPacket();
delay(10);  // ~100Hz

Python UDP 수신 (M5Core2_UDP_RX.py)

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((UDP_IP, UDP_PORT))
data, addr = sock.recvfrom(1024)
# parts: ms, qw, qx, qy, qz → quaternion_wifi_log.csv

③ ESP-NOW

ESP-NOW는 WiFi 기반이지만 AP/라우터 없이 디바이스 간 직접 통신하는 프로토콜이다. M5Core2(TX)에서 IMU로 쿼터니언을 계산한 뒤 struct_message(ms, qw, qx, qy, qz)로 묶어 esp_now_send로 브로드캐스트 주소에 전송한다. 수신 보드(RX)는 USB로 PC에 연결되어 있고, ESP-NOW로 받은 패킷을 Serial(921600)로 PC에 CSV 형식으로 출력한다. PC에서는 RX가 연결된 COM 포트를 열어 시리얼로 수신해 esp_now_quats.csv 등으로 저장한다. delay(5)로 약 200Hz 수준의 고속 스트림이 가능하다.

M5Core2 ESP-NOW TX (M5Core2_espnow_TX.ino)

typedef struct struct_message { uint32_t ms; float qw, qx, qy, qz; } struct_message;
esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));
delay(5);  // ~200Hz

ESP-NOW RX → Serial (M5Core2_espnow_RX.ino)

Serial.begin(921600);
void OnDataRecv(...) {
    Serial.printf("%d,%lu,%.4f,%.4f,%.4f,%.4f\n", id, ms, qw, qx, qy, qz);
}

실습을 통해 BLE는 페어링과 대역폭 제한, UDP는 WiFi 설정과 지연, ESP-NOW는 저지연·고속이지만 RX 보드가 필요하다는 차이를 체감할 수 있다.

12. 실습 Task II·III: CNN 압축과 보드 추론

Task II (Open Problem)에서는 "action" IMU 데이터를 PC로 수집한다. 위에서 성공한 프로토콜(BLE, UDP, ESP-NOW) 중 하나를 사용하거나, 이전 시간에 사용한 Serial(UART)로 캡처한 데이터를 사용할 수 있다.

모델 개발: CNN으로 모델을 개발하고 h5 포맷으로 저장한다. tensorflow-model-optimization 패키지를 사용해 CNN 개발 과정에서 pruning을 적용한다. 패키지 설치가 안 되면 수동(manual) pruning을 한다. model compression %(압축률)를 계산하여 보고한다.
최적화/변환: TFLiteConverter로 float32 → int8 변환(양자화)한다. tflite 모델로 export하고, 모델을 C++ header 파일로 변환해 임베디드에 올릴 수 있게 한다.

Task III: 결과 비교/개선/보드 추론

비교 대상 모델은 (1) 기본 h5, (2) pruned h5, (3) quantized tflite 세 종류다. 정확도(accuracy)와 시간(timing)을 비교하고 결과를 표로 정리(tabulate)한다. tflite 결과가 나쁘면 개선(improve)하고, 개선된 tflite로 M5Core2에서 실제 추론을 수행한다.

이를 통해 "이식성과 효율의 트레이드오프"와 "모델 압축 → TFLite → Tiny 디바이스 배포" 전체 파이프라인을 한 번에 경험하게 된다.

13. 정리

이번 수업에서는 임베디드 환경에서의 이식성·효율 트레이드오프, ML 모델의 정확도와 연산량 관계, 대표 CNN 비교, 그리고 모델 압축 기법(Pruning, Quantization, Knowledge Distillation)을 이론으로 다뤘다.

실습에서는 M5Core2에서 PC로 IMU 데이터를 전송하는 세 가지 방식(BLE, WiFi UDP, ESP-NOW)을 구현하고 비교했고, CNN 모델에 프루닝과 양자화를 적용해 TFLite로 변환한 뒤 정확도·시간을 비교하고 M5Core2에 배포하는 과정까지 맛봤다.

TinyML은 제한된 메모리와 전력에서 모델을 "맞춰 넣는" 문제다. 작은 모델은 더 빠르고, 메모리를 덜 쓰고, 전력을 덜 소비한다는 점을 직접 확인하는 시간이었다.

[UNLV] - 딥러닝과 합성곱 신경망(8일차)

빡성 — Sat, 14 Feb 2026 02:34:01 +0900

수업 개요: 딥러닝의 기초
인공 신경망(ANN)의 작동 원리
ANN 아키텍처 설계 프로세스
가중치 조정과 역전파
TensorFlow & Keras
심층 신경망 (DNN)
합성곱 신경망 (CNN)
실습: 간단한 신경망 예제
실습: 오디오 분류를 위한 DNN
실습: 오디오 분류를 위한 CNN
실습: USB 마이크를 이용한 오디오 녹음
실습: TFLite 모델 추론 시스템
정리

1. 수업 개요: 딥러닝의 기초

이번 수업은 딥러닝(Deep Learning)의 기초 개념과 실습을 다뤘다. 인공 신경망(ANN)의 작동 원리부터 시작해, 심층 신경망(DNN)과 합성곱 신경망(CNN)까지 이론과 실습을 함께 진행했다.

특히 오디오 분류 문제를 통해 DNN과 CNN의 차이점을 직접 경험했다. DNN은 MFCC 특성의 평균값을 사용하고, CNN은 시간 정보를 보존한 MFCC 시퀀스를 사용한다는 점이 핵심이었다.

실습에서는 TensorFlow와 Keras를 사용하여 모델을 구축하고, TFLite로 변환하여 임베디드 시스템에서 실행 가능한 형태로 만들었다.

2. 인공 신경망(ANN)의 작동 원리

인공 신경망은 생물학적 뉴런의 작동 방식을 모방한 계산 모델이다. 인공 뉴런은 여러 입력에 가중치를 적용하고, 편향과 함께 합산한 후 활성화 함수를 거쳐 출력을 생성한다.

뉴런 구조:

Σ = X₁w₁ + X₂w₂ + ... + Xₘwₘ + b = y

여기서:

X₁, X₂, ..., Xₘ: 입력 값들
w₁, w₂, ..., wₘ: 각 입력에 대한 가중치
b: 편향(Bias)
Σ: 합산 유닛(Summation unit)
y: 전달 함수(Transfer function)를 거친 최종 출력

활성화 함수: 가장 흔히 사용되는 것은 시그모이드(Sigmoid) 함수다. 시그모이드는 출력을 0과 1 사이의 값으로 변환하여 비선형성을 추가한다. 최근에는 ReLU(Rectified Linear Unit) 함수도 널리 사용된다.

활성화 함수가 없으면 신경망은 선형 변환만 수행할 수 있어 복잡한 패턴을 학습할 수 없다. 비선형 활성화 함수가 있어야 신경망이 복잡한 관계를 모델링할 수 있다.

3. ANN 아키텍처 설계 프로세스

신경망을 설계하고 훈련하는 과정은 다음과 같은 단계로 이루어진다:

입력을 받음: 데이터를 신경망에 입력한다.
편향(Bias) 추가: 필요시 편향을 추가한다.
입력 특징에 무작위 가중치 할당: 초기 가중치는 보통 [-1, 1] 사이의 작은 무작위 값으로 설정한다.
훈련 코드 실행: 모델을 학습시킨다.
예측 오류 확인: 모델의 예측과 실제 값 사이의 오차를 계산한다.
경사 하강법으로 가중치 업데이트: 오차를 최소화하는 방향으로 가중치를 조정한다.
업데이트된 가중치로 훈련 반복: 위 과정을 반복하여 모델 성능을 향상시킨다.
예측 수행: 학습이 완료된 모델로 새로운 데이터에 대한 예측을 수행한다.

설계 이슈:

초기 가중치 설정: 보통 [-1, 1] 사이의 작은 무작위 값으로 초기화한다. 잘못된 초기화는 학습을 방해할 수 있다.
활성화 함수 선택: 문제 유형에 따라 적절한 활성화 함수를 선택해야 한다.
오차 추정 및 가중치 조정: 경사 하강법 최적화 알고리즘을 사용한다.
뉴런의 수: 너무 적으면 학습 능력이 부족하고, 너무 많으면 과적합이 발생할 수 있다.
데이터 표현 방식: 입력 데이터를 어떻게 전처리하고 표현할지 결정한다.
훈련 세트의 크기: 충분한 데이터가 있어야 모델이 일반화할 수 있다.

4. 가중치 조정과 역전파

신경망 학습의 핵심은 가중치 조정이다. 목표는 반복할 때마다 오차(Error)를 최소화하도록 가중치를 조정하는 것이다.

역전파(Back propagation): 가중치를 업데이트하는 방향을 결정하는 알고리즘이다. 출력층에서 계산된 오차를 입력층 방향으로 역전파하여 각 가중치의 기여도를 계산한다.

역전파는 연쇄 법칙(Chain Rule)을 사용하여 각 가중치의 기여도를 계산한다. 이 과정을 반복하면서 모델이 점진적으로 정확도를 향상시킨다.

학습률(Learning Rate): 업데이트 시 한 번에 이동할 단계의 크기를 결정하는 튜닝 파라미터다. 학습률이 너무 크면 최적점을 지나쳐버리고, 너무 작으면 학습이 느리게 진행된다.

손실 함수(Loss Function)는 모델의 예측과 실제 값 사이의 차이를 측정한다. 경사 하강법을 통해 오차(Cost)를 최소화하는 지점으로 가중치가 업데이트된다.

5. TensorFlow & Keras

TensorFlow: 머신러닝의 복잡한 수학 연산을 수행하는 엔진이다. 수치 계산을 그래프(Graph)로 표현하는 것이 핵심 아이디어다.

TensorFlow에서 노드(Nodes)는 연산(Ops)을 나타내고, 엣지(Edges)는 데이터인 텐서(Tensors)의 흐름을 나타낸다. 예를 들어, f(x, y, z) = (x + y) * z 같은 수식을 그래프로 구현하여 계산한다.

Keras: TensorFlow 기반의 고수준 API로, 모델 구축과 빠른 프로토타이핑에 용이하다. 복잡한 TensorFlow 코드를 간단하게 작성할 수 있게 해준다.

TensorFlow Lite (TFLite): 리소스가 제한된 장치(모바일, IoT, 임베디드 시스템)를 위한 경량 버전이다. 특징은 다음과 같다:

모델 변환 및 최적화
온디바이스 추론
저지연
작은 점유 공간

Keras 훈련 옵션:

옵티마이저(Optimizer):
- sgd: 확률적 경사 하강법
- adam: 적응형 학습률 알고리즘
손실 함수(Loss):
- binary_crossentropy: 이진 분류용
- categorical_crossentropy: 다중 클래스 분류용
- mean_squared_error: 회귀 문제용
콜백(Callbacks): EarlyStopping(조기 종료), ModelCheckpoint(최적 모델 저장) 등

6. 심층 신경망 (DNN)

DNN 정의: 입력층과 출력층 사이에 여러 개의 은닉층(Hidden layers)이 있는 신경망이다.

일반 NN vs DNN:

일반 NN: 층이 적음 → 단순한 패턴 학습
DNN: 층이 많음 → 복잡하고 계층적인 패턴 학습

DNN은 층이 깊어질수록 더 추상적이고 복잡한 특징을 학습할 수 있다. 첫 번째 은닉층은 저수준 특징을, 마지막 은닉층은 고수준 특징을 학습한다.

하지만 층이 너무 많으면 과적합(Overfitting)이 발생할 수 있으므로, 드롭아웃(Dropout) 같은 규제 기법이 필요하다. DNN에서 드롭아웃 비율은 보통 0.3~0.5를 권장한다.

7. 합성곱 신경망 (CNN)

CNN은 이미지나 시계열 데이터에서 공간적 또는 시간적 패턴을 학습하는 데 특화된 신경망이다.

완전 연결층의 문제: 이미지를 픽셀 단위로 일렬로 펼쳐 입력하면 파라미터가 폭증하고 공간 정보(Spatial information)가 손실된다. 예를 들어, 28×28 이미지를 784개의 입력으로 펼치면 인접 픽셀 간의 관계가 무너진다.

합성곱(Convolution)의 해결책: 이미지의 작은 패치(Patch)를 은닉층의 단일 뉴런에 연결하여 공간 구조를 보존한다. 필터(Filter/Kernel)가 이미지 위를 슬라이딩하며 연산하여 특징 맵(Feature map)을 생성한다.

합성곱 파라미터:

필터 크기(f): 필터의 크기 (예: 3×3, 5×5)
스트라이드(s): 필터가 이동하는 간격
패딩(p): 이미지 주변에 추가하는 영역

레이어 스택: 합성곱, ReLU, 풀링(Pooling) 레이어를 차례로 배치한다. 층이 깊어질수록 필터는 더 크고 복잡한 특징을 배우고, 특징 맵의 크기는 작아진다.

배치 정규화(BatchNorm): 레이어의 출력을 정규화하여 훈련을 더 빠르고 안정적으로 만든다.

완전 연결층: 합성곱 층에서 추출된 고수준 특징들을 비선형적으로 조합하여 객체를 인식한다.

드롭아웃: CNN에서 드롭아웃 비율은 보통 0.1~0.3을 권장한다. DNN보다 낮은 이유는 합성곱 레이어 자체가 이미 규제 효과가 있기 때문이다.

소프트맥스(Softmax) 레이어: 출력층 직전에 위치하며, 입력 벡터를 확률 분포로 변환하여 반환한다. 모든 출력의 합은 1이며, 출력층과 동일한 수의 노드를 가져야 한다.

CNN 아키텍처 요약:

특징 학습(Feature Learning): INPUT → CONVOLUTION + RELU → POOLING 반복
분류(Classification): FLATTEN → FULLY CONNECTED → SOFTMAX → 최종 분류

8. 실습: 간단한 신경망 예제

가장 간단한 신경망 예제로 X(-1, 0, 1, 2, 3, 4)와 Y(-3, -1, 1, 3, 5, 7) 사이의 관계를 찾는 문제를 풀었다. 이는 선형 관계 Y = 2X - 1을 학습하는 문제다.

간단한 신경망 예제 (simple_NN_example.py)

import numpy as np
from tensorflow import keras

# 1. Define the model
model = keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])

# 2. Compile the model
model.compile(optimizer='sgd', loss='mean_squared_error')

# 3. Define the data
xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

# 4. Train the model
model.fit(xs, ys, epochs=50)

# 5. Make a prediction
print(model.predict(np.array([10.0])))

이 예제는 단일 뉴런으로 구성된 가장 간단한 신경망이다. Dense 레이어 하나만 사용하여 선형 관계를 학습한다. 에포크가 진행될수록 손실(loss) 값이 감소하는 것을 확인할 수 있었다.

9. 실습: 오디오 분류를 위한 DNN

오디오 분류 문제를 DNN으로 해결하는 실습을 진행했다. 5가지 클래스(Clap, Cough, Footsteps, Glassbreak, Knock)를 분류하는 모델을 구축했다.

DNN의 특징: MFCC 특성을 추출한 후 시간에 대한 평균을 계산하여 1D 벡터로 만든다. 이렇게 하면 시간 정보가 손실되지만, 파라미터 수가 줄어들고 계산이 빠르다.

DNN 오디오 분류 (DNN_audio_classification.py)

import librosa
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout

# MFCC 추출 후 평균 계산 (DNN용)
def extract_features_dnn(file_path, label):
    features = []
    labels = []
    
    y, sr = librosa.load(file_path, sr=22050)
    n_samples = int(0.5 * sr)  # 0.5초 세그먼트
    step = int(0.25 * sr)  # 50% 오버랩
    
    for start in range(0, len(y) - n_samples + 1, step):
        segment = y[start:start + n_samples]
        
        # MFCC 추출 (Shape: n_mfcc, time_steps)
        mfcc = librosa.feature.mfcc(y=segment, sr=sr, n_mfcc=40)
        
        # DNN: 시간에 대한 평균 (1D 벡터)
        mfcc_mean = np.mean(mfcc.T, axis=0)  # Shape: (40,)
        
        features.append(mfcc_mean)
        labels.append(label)
    
    return features, labels

# DNN 모델 구축
model = Sequential([
    Dense(256, activation='relu', input_shape=(40,)),
    Dropout(0.3),
    Dense(128, activation='relu'),
    Dropout(0.3),
    Dense(64, activation='relu'),
    Dense(5, activation='softmax')  # 5개 클래스
])

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

# 모델 학습
history = model.fit(X_train, y_train, 
                    epochs=50, 
                    batch_size=32, 
                    validation_data=(X_test, y_test))

# TFLite로 변환
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with open('audio_dnn_model.tflite', 'wb') as f:
    f.write(tflite_model)

DNN 모델은 다음과 같은 구조를 가진다:

입력층: 40차원 MFCC 평균 벡터
은닉층 1: 256 뉴런, ReLU 활성화, Dropout 0.3
은닉층 2: 128 뉴런, ReLU 활성화, Dropout 0.3
은닉층 3: 64 뉴런, ReLU 활성화
출력층: 5 뉴런, Softmax 활성화

학습 결과를 평가하기 위해 정확도, 정밀도, 재현율, F1-Score를 계산하고, 혼동 행렬(Confusion Matrix)을 시각화했다.

10. 실습: 오디오 분류를 위한 CNN

같은 오디오 분류 문제를 CNN으로 해결하는 실습을 진행했다. CNN은 시간 정보를 보존한 MFCC 시퀀스를 사용한다는 점이 DNN과 다르다.

CNN의 특징: MFCC 특성을 추출한 후 전체 시간 시퀀스를 그대로 사용한다. 이렇게 하면 시간적 패턴을 학습할 수 있다. 합성곱 층은 parameter sharing으로 파라미터 수는 FC에 비해 적게 유지되지만, 2D 시퀀스 전체에 대해 연산하므로 계산은 더 복잡해진다.

CNN 오디오 분류 (CNN_audio_classification.py)

import librosa
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout

# MFCC 추출 후 시퀀스 유지 (CNN용)
def extract_features_cnn(file_path, label):
    features = []
    labels = []
    
    y, sr = librosa.load(file_path, sr=22050)
    n_samples = int(0.5 * sr)
    step = int(0.25 * sr)
    
    for start in range(0, len(y) - n_samples + 1, step):
        segment = y[start:start + n_samples]
        
        # MFCC 추출
        mfcc = librosa.feature.mfcc(y=segment, sr=sr, n_mfcc=40)
        
        # CNN: 시간 시퀀스 유지 (2D 배열)
        mfcc = mfcc.T  # Shape: (time_steps, 40)
        
        features.append(mfcc)
        labels.append(label)
    
    return features, labels

# 1D CNN 모델 구축
input_shape = (22, 40)  # (time_steps, n_mfcc)

model = Sequential([
    # 합성곱 레이어 1
    Conv1D(filters=32, kernel_size=3, activation='relu', input_shape=input_shape),
    MaxPooling1D(pool_size=2),
    Dropout(0.2),
    
    # 합성곱 레이어 2
    Conv1D(filters=64, kernel_size=3, activation='relu'),
    MaxPooling1D(pool_size=2),
    Dropout(0.2),
    
    # 완전 연결층
    Flatten(),
    Dense(64, activation='relu'),
    Dropout(0.3),
    Dense(5, activation='softmax')
])

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

# 모델 학습
history = model.fit(X_train, y_train, 
                    epochs=30, 
                    batch_size=32, 
                    validation_data=(X_test, y_test))

# TFLite로 변환
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with open('audio_cnn_model.tflite', 'wb') as f:
    f.write(tflite_model)

CNN 모델은 다음과 같은 구조를 가진다:

입력층: (22, 40) 형태의 MFCC 시퀀스
합성곱 레이어 1: 32개 필터, 커널 크기 3, MaxPooling, Dropout 0.2
합성곱 레이어 2: 64개 필터, 커널 크기 3, MaxPooling, Dropout 0.2
Flatten: 2D 특징 맵을 1D로 변환
완전 연결층: 64 뉴런, ReLU 활성화, Dropout 0.3
출력층: 5 뉴런, Softmax 활성화

데이터의 시간적·공간적 국소 패턴이 중요한 문제에서는 CNN이 일반화에 더 유리한 경향을 보인다. 모델 크기와 계산 비용은 네트워크 설계(층 수, 필터 수, 완전 연결층 규모 등)에 따라 달라지며, 많은 CNN에서도 파라미터의 상당 부분은 마지막 완전 연결층이 차지한다.

11. 실습: USB 마이크를 이용한 오디오 녹음

Raspberry Pi Zero W2에 USB 마이크를 연결하여 오디오를 녹음하는 실습을 진행했다. 이는 오디오 분류 모델 학습을 위한 데이터 수집 과정이다.

USB 마이크 녹음 (rpi_USB_mic.py)

import sounddevice as sd
from scipy.io.wavfile import write
import numpy as np

# 설정
DURATION = 2  # 녹음 시간 (초)
SAMPLE_RATE = 22050  # 샘플링 레이트
OUTPUT_FILENAME = "rpi_mic_recording.wav"

def list_input_devices():
    """사용 가능한 입력 장치 목록 출력"""
    print("\n--- Available Audio Devices ---")
    devices = sd.query_devices()
    input_devices = []
    
    for i, device in enumerate(devices):
        if device['max_input_channels'] > 0:
            print(f"ID {i}: {device['name']}")
            input_devices.append(i)
    return input_devices

def record_from_device(device_id):
    print(f"\n녹음 준비: {DURATION}초, Device ID {device_id}...")
    
    try:
        # 녹음 시작
        audio_data = sd.rec(int(DURATION * SAMPLE_RATE),
                            samplerate=SAMPLE_RATE,
                            channels=1,
                            device=device_id,
                            dtype='int16')
        
        print("녹음 중... (지금 말하세요!)")
        sd.wait()  # 녹음 완료까지 대기
        print("완료.")
        
        # 파일로 저장
        write(OUTPUT_FILENAME, SAMPLE_RATE, audio_data)
        print(f"저장 완료: '{OUTPUT_FILENAME}'")
        
    except Exception as e:
        print(f"녹음 오류: {e}")

if __name__ == "__main__":
    # 1. 장치 목록 출력
    valid_ids = list_input_devices()
    
    # 2. 사용자가 USB 마이크 ID 선택
    print("\n위 목록에서 'USB Audio Device' 또는 유사한 이름을 찾으세요.")
    try:
        selected_id = int(input("USB 마이크의 ID 번호를 입력하세요: "))
        
        if selected_id in valid_ids:
            record_from_device(selected_id)
        else:
            record_from_device(selected_id)  # 폴백 체크
            
    except ValueError:
        print("잘못된 입력입니다. 숫자를 입력하세요.")

이 스크립트는 다음과 같은 기능을 제공한다:

사용 가능한 오디오 입력 장치 목록 출력
사용자가 USB 마이크를 선택
지정된 시간 동안 오디오 녹음
WAV 파일로 저장

녹음된 오디오는 이후 MFCC 특성 추출 및 모델 학습에 사용된다.

12. 실습: TFLite 모델 추론 시스템

학습된 모델을 TFLite로 변환하고, 실제 오디오 파일에 대해 추론을 수행하는 시스템을 구축했다.

TFLite 추론 시스템 (CNN_classfication_inference_sys.py)

import numpy as np
import librosa
import tensorflow.lite as tflite

# 설정
MODEL_TYPE = 'dnn'  # 또는 'cnn'
MODEL_PATH = f"audio_{MODEL_TYPE}_model.tflite"
TEST_AUDIO_FILE = "test_audio.wav"

SAMPLE_RATE = 22050
DURATION = 0.5
OVERLAP = 0.25
N_MFCC = 40
CLASSES = ['Clap', 'Cough', 'Footsteps', 'Glassbreak', 'Knock']

def preprocess_dnn(segment, sr):
    """DNN 전처리: MFCC 평균 계산"""
    mfccs = librosa.feature.mfcc(y=segment, sr=sr, n_mfcc=N_MFCC)
    features = np.mean(mfccs.T, axis=0)
    return features.reshape(1, -1).astype(np.float32)

def preprocess_cnn(segment, sr, target_time_steps):
    """CNN 전처리: MFCC 시퀀스 유지"""
    mfccs = librosa.feature.mfcc(y=segment, sr=sr, n_mfcc=N_MFCC)
    features = mfccs.T  # (time_steps, n_mfcc)
    
    # 고정 길이로 패딩 또는 자르기
    if features.shape[0] < target_time_steps:
        pad_width = target_time_steps - features.shape[0]
        features = np.pad(features, ((0, pad_width), (0, 0)), mode='constant')
    else:
        features = features[:target_time_steps, :]
    
    return np.expand_dims(features, axis=0).astype(np.float32)

def run_inference(audio_path, model_path, model_type):
    # 1. 모델 로드
    interpreter = tflite.Interpreter(model_path=model_path)
    interpreter.allocate_tensors()
    
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()
    
    input_index = input_details[0]['index']
    output_index = output_details[0]['index']
    
    # 2. 오디오 로드
    y, sr = librosa.load(audio_path, sr=SAMPLE_RATE)
    
    # 3. 슬라이딩 윈도우 추론
    n_samples = int(DURATION * sr)
    step = int((DURATION - OVERLAP) * sr)
    
    predictions = []
    
    for i in range(0, len(y) - n_samples + 1, step):
        segment = y[i: i + n_samples]
        
        # 전처리
        if model_type == 'dnn':
            input_data = preprocess_dnn(segment, sr)
        elif model_type == 'cnn':
            target_time_steps = input_details[0]['shape'][1]
            input_data = preprocess_cnn(segment, sr, target_time_steps)
        
        # 추론
        interpreter.set_tensor(input_index, input_data)
        interpreter.invoke()
        output_data = interpreter.get_tensor(output_index)
        
        # 결과 디코딩
        pred_idx = np.argmax(output_data[0])
        confidence = output_data[0][pred_idx]
        label = CLASSES[pred_idx]
        
        start_time = i / sr
        end_time = (i + n_samples) / sr
        
        predictions.append(label)
        print(f"Time {start_time:.2f}s - {end_time:.2f}s: {label:<10} (Conf: {confidence:.2f})")
    
    # 4. 최종 다수결 투표
    from collections import Counter
    most_common = Counter(predictions).most_common(1)
    print(f"\nFINAL PREDICTION: {most_common[0][0]}")

이 추론 시스템은 다음과 같은 기능을 제공한다:

TFLite 모델 로드 및 초기화
오디오 파일을 세그먼트로 분할
각 세그먼트에 대해 추론 수행
다수결 투표로 최종 예측 결정

슬라이딩 윈도우 방식을 사용하여 긴 오디오 파일도 처리할 수 있다. 각 세그먼트의 예측 결과를 수집한 후, 가장 많이 예측된 클래스를 최종 결과로 선택한다.

13. 정리

이번 수업을 통해 딥러닝의 기초 개념부터 실전 적용까지 전 과정을 경험했다. 인공 신경망의 작동 원리를 이해하고, DNN과 CNN의 차이점을 오디오 분류 문제를 통해 직접 확인했다.

특히 중요한 것은 "DNN은 시간 정보를 평균내어 손실하지만 빠르고, CNN은 시간 정보를 보존하여 더 정확하지만 계산 비용이 높다"는 점이었다. 문제의 특성에 따라 적절한 모델을 선택하는 것이 중요하다.

TensorFlow와 Keras를 사용하여 모델을 구축하고, TFLite로 변환하여 임베디드 시스템에서 실행 가능한 형태로 만드는 과정을 배웠다. 이는 실제 IoT 프로젝트에서 매우 유용한 기술이다.

이 수업에서 다룬 내용은 앞으로 이미지 분류, 음성 인식, 센서 데이터 분석 등 다양한 딥러닝 프로젝트에 적용할 수 있다. 특히 CNN의 합성곱 연산과 풀링의 개념은 컴퓨터 비전 분야에서 필수적이다.

[UNLV] - 데이터 엔지니어링과 MQTT 스트리밍(7일차)

빡성 — Fri, 13 Feb 2026 02:20:26 +0900

수업 개요: 데이터 엔지니어링과 스트리밍
데이터 엔지니어링의 정의와 프로세스
데이터 수집 (Data Collection)
MQTT 프로토콜과 Pub/Sub 모델
데이터 전처리 (Data Pre-processing)
Data Drift와 Concept Drift
실습: M5Core2 + AHT20 센서로 MQTT 발행
실습: Python MQTT 구독자 및 데이터 로깅
실습: 다중 디바이스 데이터 집계
실습: RPi + PCT2075 센서로 MQTT 발행
시뮬레이션: 합성 데이터 생성 및 전처리
정리

1. 수업 개요: 데이터 엔지니어링과 스트리밍

이번 수업은 데이터 엔지니어링(Data Engineering)과 실시간 데이터 스트리밍에 대해 다뤘다. 데이터 엔지니어링은 분석 및 의사 결정을 위해 원시 데이터를 수집, 처리하고 구조화된 형식으로 변환하는 프로세스와 기술을 포함한다.

특히 IoT 환경에서 여러 센서로부터 실시간으로 데이터를 수집하고 처리하는 방법을 MQTT(Message Queuing Telemetry Transport) 프로토콜을 통해 실습했다. MQTT는 경량 메시징 프로토콜로, IoT 디바이스 간 통신에 최적화되어 있다.

실습에서는 M5Stack Core2와 Raspberry Pi Zero W2를 사용하여 엔드 투 엔드 IoT 데이터 파이프라인을 구축했다. 센서 데이터를 MQTT로 발행하고, Python으로 구독하여 CSV 파일로 저장하고 시각화하는 전체 과정을 경험했다.

2. 데이터 엔지니어링의 정의와 프로세스

데이터 엔지니어링은 원시 데이터를 수집, 처리 및 구조화되고 사용 가능한 형식으로 변환하는 프로세스와 기술을 포함한다. 머신러닝 모델이 제대로 작동하려면 고품질의 데이터가 필요하며, 데이터 엔지니어링은 이를 보장하는 핵심 단계다.

데이터 엔지니어링의 주요 프로세스는 다음과 같다:

수집 (Gathering / Collection): 다양한 소스로부터 데이터를 가져온다.
정제 (Refinement): 데이터를 정제하고 변환한다.
유지 관리 (Sustainment): 데이터 파이프라인을 지속적으로 관리한다.
처리 (Processing): 데이터를 분석 가능한 형태로 가공한다.
검증 (Validation): 데이터 품질을 확인한다.
저장소 (Storage): 데이터를 적절한 저장소에 저장한다.
보안 (Security): 데이터 접근 권한과 프라이버시를 관리한다.
증강 (Augmentation): 데이터에 추가 정보를 결합한다.
라벨링 (Labeling): 지도 학습을 위한 레이블을 생성한다.
버전 관리 (Versioning): 데이터셋의 버전을 추적한다.

데이터 엔지니어링에서 중요한 것은 요구사항 정의다. 문제 정의, 권한 및 권리, 기계 및 인간이 사용 가능한 형식 등을 명확히 해야 한다.

3. 데이터 수집 (Data Collection)

데이터 수집은 데이터 엔지니어링의 첫 단계다. 다양한 소스로부터 원시 데이터를 가져와야 한다.

데이터 소스 (Sources of Data):

센서: IoT, IMU, 환경, 의료, 산업용 센서
로그: 시스템, 애플리케이션, 클릭스트림, 텔레메트리
API: 금융, 날씨, 소셜 미디어 등 외부 API
데이터베이스: SQL/NoSQL 엑스포트
사용자 생성 데이터: 이미지, 텍스트, 라벨, 크라우드소싱
공공 데이터셋: UCI, Kaggle, OpenML

수집 방법 (Collection Methods):

배치 데이터 캡처: CSV/JSON 덤프 등 주기적 수집
스트리밍 데이터 캡처: Kafka, MQTT, RabbitMQ 등 실시간 수집
엣지/임베디드 수집: TinyML 장치, 모바일 앱

도전 과제 (Challenges):

데이터 라벨링 및 주석: 수동, 반자동, 능동 학습
데이터 프라이버시 및 윤리: 동의, 익명화
데이터 품질: 누락, 노이즈, 중복, 편향

4. MQTT 프로토콜과 Pub/Sub 모델

MQTT는 IoT 환경에서 널리 사용되는 경량 메시징 프로토콜이다. Publish/Subscribe (Pub/Sub) 모델을 사용하여 데이터 소스와 데이터 소비자를 분리(Decouple)한다.

전통적인 "Polling" 방식과 달리 MQTT는 "Push" 모델을 사용한다. 장치는 데이터가 있을 때만 전송하고 서버는 즉시 수신한다. 이는 배터리 소비를 줄이고 실시간성을 향상시킨다.

MQTT 데이터 흐름 파이프라인:

수집 (Publishers): 센서(엔드 디바이스)가 깨어나 데이터를 읽고 특정 Topic(예: factory/machine_01/temp)으로 페이로드를 발행한다.
전송 (Broker): 중앙 MQTT 브로커(예: Mosquitto)가 메시지를 수신하고, 해당 토픽을 구독하는 대상에게 데이터를 필터링하여 라우팅한다.
처리 (Subscribers): 백엔드 시스템(DB, 대시보드, AI 모델)이 관심 토픽을 구독하여 저장 또는 분석을 위해 실시간으로 수신한다.

MQTT의 장점은 다음과 같다:

경량 프로토콜로 저전력 디바이스에 적합
Pub/Sub 모델로 확장성이 뛰어남
Topic 기반 필터링으로 효율적인 메시지 라우팅
QoS(Quality of Service) 레벨로 신뢰성 보장

5. 데이터 전처리 (Data Pre-processing)

데이터 과학자는 시간의 50% 이상을 데이터 전처리에 소비한다. 데이터 수집은 두 번째로 많은 시간이 소요되는 구성 요소이며, 알고리즘 튜닝은 적은 부분을 차지한다.

시간 소요 비중:

데이터 전처리 (Data preprocessing): 60%
데이터 수집 (Collecting Data): 19%
데이터 패턴 인식 (Recognizing Data Patterns): 9%
학습 데이터 구축 (Constructing Training Data): 4%
알고리즘 튜닝 (Tuning Algorithm): 3%
기타 (Others): 5%

왜 데이터 전처리를 하는가?

원시 데이터는 다음과 같은 문제를 포함할 수 있다:

불완전함 (Incomplete): 속성이 부족하거나 결측값이 포함됨
노이즈 (Noisy): 이상치와 같은 잘못된 레코드 포함
불일치 (Inconsistent): 충돌하는 레코드나 불일치 발생
결측값 (Missing values): 일부 속성이 비어있거나 NULL임
유효하지 않은 값 (Invalid Values): 성별 등 속성에 잘못된 값 입력
고유성 (Uniqueness): 동일 식별자의 반복된 값
오타 (Misspellings): 잘못 적힌 값들

데이터 전처리 기법:

결측값 (Missing Values): 제거 또는 대체(평균, 중앙값, 보간법 등)로 처리
이상치 (Outliers): 모델 왜곡을 방지하기 위해 극단값을 감지하고 처리
데이터 스케일링 (Data Scaling): 모든 변수가 동등하게 기여하도록 정규화 또는 표준화
- 정규화 (Normalization): 데이터를 0-1 사이의 고정 범위로 재조정
- 표준화 (Standardization): 평균 0, 분산 1로 변환 (z-score)
다운샘플링 (Down-sampling): 계산/저장 비용을 줄이기 위해 데이터 속도나 샘플 수 감소
업샘플링 (Up-sampling): 데이터 복제 또는 합성을 통해 샘플 속도를 높이거나 클래스 불균형 해소
노이즈 필터링 (Noise Filtering): 센서 데이터에서 원치 않는 고주파 또는 무작위 변동 제거
평활화 (Smoothing): 이동 평균 등을 적용하여 단기 변동 감소
인코딩 (Encoding): 범주형 데이터를 수치 표현(One-hot 등)으로 변환

6. Data Drift와 Concept Drift

머신러닝 모델을 배포한 후에도 데이터는 계속 변화한다. 이러한 변화를 감지하고 대응하는 것이 중요하다.

Data Drift: 작업(Task)은 변하지 않지만, 시간이 지남에 따라 입력 데이터의 통계적 분포가 변하는 현상이다. 예를 들어, 센서가 노화되거나 환경이 변하면 데이터 분포가 달라질 수 있다.

Concept Drift: 시간이 지남에 따라 입력 데이터와 타겟 라벨 사이의 근본적인 관계가 변하는 현상이다. 예를 들어, 사용자 행동 패턴이 바뀌면 모델의 결정 경계가 더 이상 유효하지 않을 수 있다.

비교:

Data Drift: 입력 피처(x)의 분포 변화
Concept Drift: 결정 경계(Decision boundary)의 변화, 피처-라벨 관계 변화

두 현상 모두 모델 성능 저하를 야기할 수 있으므로, 지속적인 모니터링과 재학습이 필요하다.

7. 실습: M5Core2 + AHT20 센서로 MQTT 발행

실습에서는 M5Stack Core2에 AHT20 온습도 센서를 연결하고, 센서 데이터를 MQTT 브로커로 발행하는 시스템을 구축했다.

하드웨어 구성:

M5Stack Core2 (Wi-Fi 지원)
AHT20 온습도 센서 (I2C 통신)
Raspberry Pi Zero W2 (MQTT 브로커)

배선 (AHT20 to M5Core2 Port A):

GND (Black) → GND
5V (Red) → VIN/VCC
G32 (White) → SDA
G33 (Yellow) → SCL

필요한 라이브러리:

M5Unified (M5Stack 통합 라이브러리)
PubSubClient (MQTT 클라이언트)
ArduinoJson (JSON 처리)
Adafruit AHTX0 (AHT20 센서 드라이버)

M5Core2 AHT20 MQTT Publisher (M5Core2_AHT20_MQTT.ino)

#include <M5Unified.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include <Adafruit_AHTX0.h>

// --- USER CONFIGURATION ---
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "192.168.1.100"; // Replace with your RPi IP
const int mqtt_port = 1883;
const char* location = "Lab_M5_Unit1"; 
// --------------------------

WiFiClient espClient;
PubSubClient client(espClient);
Adafruit_AHTX0 aht;

void setup_wifi() {
  delay(10);
  M5.Display.print("Connecting to WiFi...");
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    M5.Display.print(".");
  }
  M5.Display.println("\nWiFi connected");
}

void reconnect() {
  while (!client.connected()) {
    M5.Display.print("Attempting MQTT connection...");
    String clientId = "M5Core2-";
    clientId += String((uint32_t)ESP.getEfuseMac(), HEX);
    
    if (client.connect(clientId.c_str())) {
      M5.Display.println("connected");
    } else {
      M5.Display.printf("failed, rc=%d try again in 5s\n", client.state());
      delay(5000);
    }
  }
}

void setup() {
  M5.begin();
  M5.Display.setTextSize(2);
  M5.Display.println("Init AHT20 & MQTT...");

  // Initialize I2C for Port A
  Wire.begin(32, 33); 

  if (!aht.begin(&Wire)) {
    M5.Display.println("Could not find AHT? Check wiring");
    while (1) delay(10);
  }
  M5.Display.println("AHT20 Found");

  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
}

void loop() {
  M5.update();
  
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  // 1. Get Sensor Data
  sensors_event_t humidity, temp;
  aht.getEvent(&humidity, &temp);

  float t_val = temp.temperature;
  float h_val = humidity.relative_humidity;

  // 2. Create JSON Payload
  StaticJsonDocument<256> doc;
  doc["loc"] = location;
  doc["temp"] = serialized(String(t_val, 2));
  doc["hum"] = serialized(String(h_val, 2));

  char buffer[256];
  serializeJson(doc, buffer);

  // 3. Publish
  client.publish("lab/temphum", buffer);

  // 4. Visual Feedback
  M5.Display.fillScreen(TFT_BLACK);
  M5.Display.setCursor(10, 50);
  M5.Display.printf("Loc: %s\n", location);
  M5.Display.printf("Temp: %.2f C\n", t_val);
  M5.Display.printf("Hum:  %.2f %%", h_val);
  
  delay(5000); 
}

코드의 주요 기능:

Wi-Fi 연결 및 MQTT 브로커 연결
AHT20 센서로부터 온도와 습도 데이터 읽기
JSON 형식으로 데이터 포맷팅
"lab/temphum" 토픽으로 데이터 발행
M5Stack 디스플레이에 현재 값 표시

8. 실습: Python MQTT 구독자 및 데이터 로깅

Raspberry Pi Zero W2에서 Mosquitto MQTT 브로커를 설정하고, Python 스크립트로 M5Core2에서 발행한 데이터를 구독하여 CSV 파일로 저장하는 실습을 진행했다.

MQTT Broker 설정 (Raspberry Pi):

Mosquitto 설치 및 설정

# 1. 시스템 업데이트
sudo apt update && sudo apt upgrade -y

# 2. Mosquitto 설치
sudo apt install mosquitto mosquitto-clients -y

# 3. Mosquitto 서비스 시작 및 자동 시작 설정
sudo systemctl enable mosquitto
sudo systemctl start mosquitto

# 4. 상태 확인
systemctl status mosquitto

# 5. 원격 액세스 활성화
sudo nano /etc/mosquitto/mosquitto.conf
# 다음 내용 추가:
# listener 1883
# allow_anonymous true

# 6. Mosquitto 재시작
sudo systemctl restart mosquitto

# 7. 포트 확인
ss -tulpn | grep 1883

# 8. 브로커 테스트
# 터미널 1 (구독):
mosquitto_sub -h localhost -t lab/temphum

# 터미널 2 (발행):
mosquitto_pub -h localhost -t lab/temphum -m '{"temp":25.5,"hum":60.2}'

Python MQTT 구독자:

MQTT Consumer (mqtt_loc_consumer.py)

import json
import csv
from datetime import datetime
import paho.mqtt.client as mqtt

# Configuration
TOPIC = "lab/temphum"
CSV_FILE = "temphum_log.csv"
BROKER_ADDRESS = "localhost"

# Initialize CSV with header if file doesn't exist
try:
    with open(CSV_FILE, "r") as f:
        pass
except FileNotFoundError:
    with open(CSV_FILE, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(["timestamp", "location", "temp", "hum"])
    print(f"Created new log file: {CSV_FILE}")

def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    client.subscribe(TOPIC)
    print(f"Listening on topic: {TOPIC}")
    print("-" * 65)
    print(f"{'TIMESTAMP':<22} | {'LOCATION':<15} | {'TEMP':<8} | {'HUM':<8}")
    print("-" * 65)

def on_message(client, userdata, msg):
    payload = msg.payload.decode()
    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    try:
        data = json.loads(payload)
        loc = data.get("loc", "Unknown")
        temp = float(data.get("temp", 0.0))
        hum = float(data.get("hum", 0.0))

        # Display on Terminal
        print(f"{ts:<22} | {loc:<15} | {temp:<8.2f} | {hum:<8.2f}")

        # Save to CSV
        with open(CSV_FILE, "a", newline="") as f:
            writer = csv.writer(f)
            writer.writerow([ts, loc, temp, hum])

    except json.JSONDecodeError:
        print(f"Received non-JSON message: {payload}")
    except Exception as e:
        print(f"Error processing message: {e}")

# Setup MQTT Client
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

try:
    client.connect(BROKER_ADDRESS, 1883, 60)
    client.loop_forever()
except KeyboardInterrupt:
    print("\nDisconnecting...")
    client.disconnect()
except Exception as e:
    print(f"Connection failed: {e}")

이 스크립트는 MQTT 메시지를 수신하여 터미널에 표시하고, 동시에 CSV 파일로 저장한다. 실시간으로 데이터가 수집되는 것을 확인할 수 있었다.

9. 실습: 다중 디바이스 데이터 집계

여러 M5Core2 디바이스로부터 받은 데이터의 평균을 계산하는 실습을 진행했다. 이는 분산 센서 네트워크에서 중앙 집중식 데이터 집계의 예시다.

MQTT Consumer with Average Calculation (mqtt_consumer_avg.py)

import json
import csv
import sys
from datetime import datetime
import paho.mqtt.client as mqtt

TOPIC = "lab/temphum"
CSV_FILE = "temphum_log.csv"
BROKER_ADDRESS = "localhost"

# Global dictionary to store running stats per location
location_stats = {}

def on_connect(client, userdata, flags, rc):
    print(f"Connected to MQTT Broker (Result: {rc})")
    client.subscribe(TOPIC)
    print(f"Listening on topic: {TOPIC}")
    print("=" * 90)
    print(f"{'TIMESTAMP':<20} | {'LOCATION':<12} | {'TEMP (C)':<18} | {'HUMIDITY (%)':<18}")
    print(f"{'':<20} | {'':<12} | {'Current (Avg)':<18} | {'Current (Avg)':<18}")
    print("=" * 90)

def on_message(client, userdata, msg):
    try:
        payload = msg.payload.decode()
        data = json.loads(payload)

        loc = data.get("loc", "Unknown")
        temp = float(data.get("temp", 0.0))
        hum = float(data.get("hum", 0.0))
        ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        # Update running averages
        if loc not in location_stats:
            location_stats[loc] = {"temp_sum": 0.0, "hum_sum": 0.0, "count": 0}

        stats = location_stats[loc]
        stats["temp_sum"] += temp
        stats["hum_sum"] += hum
        stats["count"] += 1

        # Calculate Averages
        avg_temp = stats["temp_sum"] / stats["count"]
        avg_hum = stats["hum_sum"] / stats["count"]

        # Display output: "25.0 (24.8)"
        temp_str = f"{temp:.1f} ({avg_temp:.1f})"
        hum_str = f"{hum:.1f} ({avg_hum:.1f})"

        print(f"{ts:<20} | {loc:<12} | {temp_str:<18} | {hum_str:<18}")

        # Save to CSV
        with open(CSV_FILE, "a", newline="") as f:
            writer = csv.writer(f)
            writer.writerow([ts, loc, temp, hum, round(avg_temp, 2), round(avg_hum, 2)])

    except json.JSONDecodeError:
        print(f"Error: Received non-JSON payload: {msg.payload}")
    except Exception as e:
        print(f"Error processing message: {e}")

# Setup MQTT Client
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

try:
    client.connect(BROKER_ADDRESS, 1883, 60)
    client.loop_forever()
except KeyboardInterrupt:
    print("\nDisconnecting...")
    client.disconnect()
except Exception as e:
    print(f"Connection failed: {e}")

이 스크립트는 각 위치별로 누적 평균을 계산하여 표시한다. 현재 값과 평균 값을 함께 보여주어 데이터의 추세를 파악할 수 있다.

10. 실습: RPi + PCT2075 센서로 MQTT 발행

Raspberry Pi Zero W2에 PCT2075 온도 센서를 연결하고, Python으로 센서 데이터를 읽어 MQTT 브로커로 발행하는 실습을 진행했다. 이는 이종 네트워크(Microcontrollers 및 SBC)로부터 환경 모니터링을 중앙 집중화하는 예시다.

하드웨어 구성:

Raspberry Pi Zero W2
PCT2075 온도 센서 (I2C 통신)

배선 (RPi Zero W2 to PCT2075):

Pin 1 (3.3V) → VCC
Pin 3 (SDA) → SDA
Pin 5 (SCL) → SCL
Pin 6 (GND) → GND

필요한 설정:

I2C 활성화: sudo raspi-config → Interface Options → I2C
라이브러리 설치: pip3 install adafruit-circuitpython-pct2075

RPi PCT2075 MQTT Publisher (rpi_publisher_pct2075.py)

import time
import json
import board
import adafruit_pct2075
import paho.mqtt.client as mqtt

# --- USER CONFIGURATION ---
MQTT_BROKER_IP = "192.168.1.100"
MQTT_PORT = 1883
MQTT_TOPIC = "lab/temphum"
LOCATION_NAME = "RPI_Node_PCT_East"
# --------------------------

# Initialize I2C bus
i2c = board.I2C()
sensor = adafruit_pct2075.PCT2075(i2c)

# MQTT Setup
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print(f"Connected to Master Broker at {MQTT_BROKER_IP}")
    else:
        print(f"Failed to connect, return code {rc}")

client = mqtt.Client()
client.on_connect = on_connect
client.connect(MQTT_BROKER_IP, MQTT_PORT, 60)
client.loop_start()

# Main Loop
try:
    while True:
        # Read Temperature
        current_temp = sensor.temperature

        # Prepare Payload (humidity is None for PCT2075)
        payload = {
            "loc": LOCATION_NAME,
            "temp": round(current_temp, 2),
            "hum": None
        }
        json_payload = json.dumps(payload)

        # Publish
        print(f"Sending: {json_payload}")
        client.publish(MQTT_TOPIC, json_payload)

        time.sleep(5)

except KeyboardInterrupt:
    print("\nStopping...")
    client.loop_stop()
    client.disconnect()

PCT2075는 온도 전용 센서이므로 습도 값은 None으로 처리한다. 이렇게 하면 M5Core2의 AHT20 데이터와 호환되는 JSON 구조를 유지할 수 있다.

11. 시뮬레이션: 합성 데이터 생성 및 전처리

실제 센서 데이터의 특성을 모방한 합성 데이터를 생성하고, 다양한 전처리 기법을 적용하여 비교하는 시뮬레이션을 진행했다.

합성 데이터 생성:

Synthetic Data Generation (generate_synthetic_data_mqtt.py)

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

def generate_and_visualize_data():
    # 7 days of data at 15-minute intervals
    dates = pd.date_range(start='2024-01-01', periods=24 * 4 * 7, freq='15min')
    n = len(dates)

    # Temperature: Daily cycle (sine wave) + random Gaussian noise
    temp_base = 20 + 10 * np.sin(np.linspace(0, 7 * 2 * np.pi, n))
    temp_noise = np.random.normal(0, 1.5, n)
    temperature = temp_base + temp_noise

    # Humidity: Inverse to temp + random noise
    humidity_base = 60 - 20 * np.sin(np.linspace(0, 7 * 2 * np.pi, n))
    humidity_noise = np.random.normal(0, 3, n)
    humidity = humidity_base + humidity_noise

    locations = np.random.choice(['Lab_A', 'Server_Room', 'Outdoor_Unit'], size=n)

    df = pd.DataFrame({
        'Timestamp': dates,
        'Location': locations,
        'Temperature': temperature,
        'Humidity': humidity
    })

    # Introduce Artifacts (Bad Data)
    # Missing Values (5% of data)
    nan_indices_t = np.random.choice(df.index, size=int(n * 0.05), replace=False)
    nan_indices_h = np.random.choice(df.index, size=int(n * 0.05), replace=False)
    df.loc[nan_indices_t, 'Temperature'] = np.nan
    df.loc[nan_indices_h, 'Humidity'] = np.nan

    # Outliers
    outlier_indices_t = np.random.choice(df.index, size=10, replace=False)
    df.loc[outlier_indices_t, 'Temperature'] = df.loc[outlier_indices_t, 'Temperature'] * 3

    outlier_indices_h = np.random.choice(df.index, size=5, replace=False)
    df.loc[outlier_indices_h, 'Humidity'] = -20

    # Save to CSV
    df.to_csv('synthetic_sensor_data.csv', index=False)
    print(f"Dataset saved to: synthetic_sensor_data.csv")

    return df

데이터 전처리 및 비교:

Data Processing Comparison (data_processing_comparison.py)

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler, StandardScaler
from scipy import stats

def process_and_visualize():
    df = pd.read_csv('synthetic_sensor_data.csv')
    df['Timestamp'] = pd.to_datetime(df['Timestamp'])
    df_clean = df.copy()

    # 1. Handle Missing Values (Linear Interpolation)
    df_clean['Temperature'] = df_clean['Temperature'].interpolate(method='linear')
    df_clean['Humidity'] = df_clean['Humidity'].interpolate(method='linear')
    df_clean.dropna(inplace=True)

    # 2. Detect & Handle Outliers (Z-Score Method)
    for col in ['Temperature', 'Humidity']:
        z_scores = np.abs(stats.zscore(df_clean[col]))
        outliers = z_scores > 3
        df_clean.loc[outliers, col] = df_clean[col].median()

    # 3. Noise Filtering / Smoothing (Moving Average)
    df_clean['Temp_Smoothed'] = df_clean['Temperature'].rolling(window=4, center=True).mean().bfill().ffill()
    df_clean['Hum_Smoothed'] = df_clean['Humidity'].rolling(window=4, center=True).mean().bfill().ffill()

    # 4. Normalization (Min-Max Scaling)
    scaler_minmax = MinMaxScaler()
    df_clean[['Temp_Norm', 'Hum_Norm']] = scaler_minmax.fit_transform(df_clean[['Temp_Smoothed', 'Hum_Smoothed']])

    # 5. Standardization (Z-Score Scaling)
    scaler_std = StandardScaler()
    df_clean[['Temp_Std', 'Hum_Std']] = scaler_std.fit_transform(df_clean[['Temp_Smoothed', 'Hum_Smoothed']])

    # 6. Encoding Categorical Data (One-Hot Encoding)
    df_clean = pd.get_dummies(df_clean, columns=['Location'], prefix='Loc')

    # Save processed data
    df_clean.to_csv('processed_sensor_data.csv', index=False)
    print("Processed data saved to: processed_sensor_data.csv")

    return df_clean

이 시뮬레이션을 통해 다음을 확인했다:

원시 데이터에 노이즈, 이상치, 결측값이 포함된 상태
전처리 후 데이터가 부드럽고 일관성 있게 변환된 상태
정규화와 표준화의 차이점
이동 평균 필터링의 효과

Data Drift와 Concept Drift 시뮬레이션:

실제 환경에서 발생할 수 있는 Data Drift와 Concept Drift를 시뮬레이션하는 코드도 작성했다. 이 코드는 3단계로 구성된다:

Baseline (정상 작동): 온도와 습도 간의 안정적인 관계
Data Drift (센서 보정 드리프트): 온도 센서가 점진적으로 5도 상승하는 드리프트 발생. 관계는 유지되지만 센서 값이 변함
Concept Drift (물리적 관계 변화): 온도와 습도 간의 관계가 반대로 변함 (음의 상관관계 → 양의 상관관계)

시뮬레이션에서는 KS-Test를 사용하여 Data Drift를 감지하고, 모델의 예측 오차(MAE)를 모니터링하여 Concept Drift를 감지한다. Drift가 감지되면 자동으로 스케일러를 업데이트하거나 모델을 재학습한다.

12. 정리

이번 수업을 통해 데이터 엔지니어링의 전체 파이프라인을 경험했다. MQTT 프로토콜을 사용한 실시간 데이터 수집부터 전처리까지의 과정을 직접 구현해볼 수 있었다.

특히 중요한 것은 "데이터 과학자는 시간의 50% 이상을 데이터 전처리에 소비한다"는 점이었다. 좋은 모델을 만들기 위해서는 고품질의 데이터가 필수이며, 이를 위해서는 체계적인 데이터 엔지니어링 프로세스가 필요하다.

MQTT의 Pub/Sub 모델은 IoT 환경에서 확장 가능한 데이터 파이프라인을 구축하는 데 매우 유용하다. 여러 디바이스로부터 데이터를 수집하고 중앙에서 집계하는 구조는 실제 산업 환경에서 널리 사용되는 패턴이다.

이 수업에서 다룬 내용은 앞으로 IoT 프로젝트나 센서 데이터 분석을 할 때 매우 유용할 것이다. 특히 MQTT를 활용한 실시간 데이터 수집과 전처리 기법을 이해한 것은 실무에서 큰 도움이 될 것 같다.