Adamas

[스나이퍼팩토리] 한컴AI아카데미 111~115일차 : 25.07.14(월)~18(금)

DS벨르 — Fri, 18 Jul 2025 17:13:49 +0900

이번주가 사실상 프로젝트 개발 마감 기한이다.

다음주 목요일이 최종발표일로 정해졌고, 그러기 위해선 월요일까지는 최종 테스트 완료 후 시연 준비를 진행해야하기 때문이다.

지속적으로 EC2 Server를 통해 여러 테스트를 진행하였다.

기존 로컬에선 오류라고 파악이 되지 않던 코드들이 여러 서버들과 연계되며 통신, 구문, 버전 등 여러 문제가 발생하여 해결 중에 있는 상황이다.

첫 시작은 HAPA Backend 서비스의 완전하고 안정적인 구동을 가로막던 핵심 문제 해결에 집중했다.

가장 먼저 발생했던 Pydantic 설정 충돌 오류를 해결했다.

Pydantic V2에서 Config와 model_config가 혼용되어 발생하는 문제임을 진단하고, Backend/app/core/settings_manager.py 파일 내 SecuritySettings 클래스에서 Config 내부 클래스를 제거하고 model_config 속성만 사용하도록 코드를 수정했다.

이를 통해 Backend 애플리케이션 로딩 초기 단계의 오류를 해결하여 서비스 구동이 한 단계 진전될 수 있게 되었습니다.

그 후 ModuleNotFoundError: No module named 'email_validator' 오류에 직면했다.

UserLoginRequest 모델에서 이메일 필드 유효성 검사를 위해 필요한 라이브러리였으나 Docker 이미지에 설치되어 있지 않아 발생한 문제였다.

Backend/requirements.txt에 email_validator를 추가해 EC2 Server에 반영 후 Docker Compose로 이미지를 재빌드하여 배포함으로써 백엔드 서비스 구동을 가로막던 두 번째 오류를 해결했다.

DATABASE_URL 환경 변수 누락 문제를 파악해 Backend/app/core/settings_manager.py에 @field_validator를 추가하여 환경 변수의 필수 여부와 유효성을 명확히 하는 유효성 검사를 구현하여 근본적인 대응 방안을 마련했다.

Pydantic 설정 충돌이나 라이브러리 누락과 같은 구동 오류를 초기에 잡았어야할 문제라고 느꼈다.

이러한 문제들을 하나씩 해결하며 백엔드 아키텍처에 대한 이해를 심화하고 재배포 과정을 체계화할 수 있었다.

Backend 구동 문제 해결 후 HAPA AI 코딩 어시스턴트의 사용자 경험을 직접적으로 저해하는 AI 응답의 과도한 생성 문제를 해결하는 Frontend에 집중했다.

print("jay")와 같은 간단한 요청에도 불필요한 파일 헤더, 주석, 작성자 정보 등 AI 모델이 과도하게 많은 내용을 생성하는 문제를 파악했다.

이 문제를 해결하기 위해 Backend/app/services/vllm_integration_service.py 내에 AI 응답 후처리 로직을 구현하고 통합했다.

종료 마커 기반 트렁케이션을 강화하여 AI 모델의 FIM 태그, 셰뱅(#!/usr/bin/env python), 파일 주석(# --- File Comment), 메타데이터(Created on:, Author:, 이메일, HTML 태그 잔재) 등 다양한 불필요 패턴을 트렁케이션 마커로 활용하여 가장 먼저 나타나는 지점부터 응답을 즉시 잘라내는 로직(_extract_content_before_end_token())을 구현했다.

트렁케이션 후에도 남을 수 있는 43개의 정교한 정규표현식 패턴들을 추가로 제거하는 _remove_unwanted_patterns() 함수를 구현하여 최종 응답을 더욱 간결하게 만들었다.

이 후처리 로직은 ChunkBuffer 클래스의 flush() 함수 및 generate_code_stream() 함수에 통합되어, 불필요한 내용이 제거된 후 프론트엔드로 전달되도록 하여 AI 응답의 품질을 대폭 향상시켰다.

AI 모델의 잠재력을 최대한 발휘하고 사용자에게 최적의 경험을 제공하기 위해서는 단순히 코드를 생성하는 것을 넘어 생성된 응답을 효과적으로 다듬는 후처리 과정이 필수적임을 깨달았다.

이번주는 정말 내내 야근의 연속이었다. 내가 맡은 영역이 절대적으로 중요한 부분인데 마무리단계에서 여러 오류가 발생하니 내가 해결 못하면 안된다라는 부담감이 정말 컸기에 야근이 필수적일 수밖에 없었다.

Python으로 Backend 작업을 처음해보기도 했고 이렇게 하나의 서비스를 짧은 시간에 vLLM 연동 서비스를 개발을 딥하게한 적이 없기에 완성도를 높여갈 때 너무 버거웠다.
게다가 Extention의 Fronten영역 대부분까지 함께 맡아왔기에 두 영역을 함께 신경써서 개발하기가 정말 힘들다라는 것을 깨닫게 되는 계기이기도 했다.

너무 욕심이었나..하는 생각과 괜히 Frontend와 Backend를 구분해서 개발하는 이유가 있구나...하는 생각이 들었다.

그래도 이렇게 풀스택으로 개발하는 것, 서비스가 Extension 이라는 것, vLLM 연동 서비스라는 것, 1인이 아닌 팀 프로젝트라는 것 등
여러 요소로 좋은 시간, 기회였다고 생각한다.

이 프로젝트 관련 학습일지로는 이번주가 마지막일 것 같아 이렇게 프로젝트 전반적인 회고도 함께 남긴다.

남은시간 마무리 잘하고 6개월간 정말 고생했다.

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미 106~110일차 : 25.07.07(월)~11(금)

DS벨르 — Fri, 11 Jul 2025 12:00:38 +0900

이번 주 첫 시작은 전반적인 Refactoring을 목표로 진행했다.

Refactoring을 진행하며 Extension의 AI 모델 플로우를 완벽하게 이해하고 최적화하기 위한 코드 심층 분석에 집중했다.

약 15,000라인이 넘는 전체 코드베이스와 25개의 핵심 파일을 분석하며 5단계 레이어 구조(Extension Entry Point, Core Management Layer, Provider Layer, Module Layer, Service Layer)를 파악했다.

특히 ExtensionManager나 TypedMessageHandler와 같은 핵심 컴포넌트의 동작 방식과 apiClient.ts, StreamingCodeGenerator, SidebarProvider 등 주요 기능 모듈의 역할을 상세히 분석했다.

이 과정에서 사용자가 AI 모델 탭을 선택하고 질문을 전송하여 응답을 받는 전체 플로우를 단계별로 추적하던 중 AI 모델과 통신하는 과정에서 세 가지 문제점을 발견했다.

첫째로 프론트엔드에서 백엔드로 전송하는 명령어 이름이 불일치했다.

둘째로 전송되는 매개변수 이름이 백엔드에서 기대하는 이름과 달랐다.

마지막으로 프론트엔드의 모델 타입이 백엔드의 VLLM 모델 타입으로 정확히 매핑되지 않는 문제가 있었다.

이 문제점들로 인해 AI 모델의 질문=>응답 기능이 제대로 작동하지 않고 의도한 대로 개인화된 응답을 받지 못하는 근본적인 원인이었다.

방대한 코드 속에서 문제의 근본 원인을 찾아내는 과정은 정말 미로를 탐색하는 것 같았다.

하지만 아키텍처를 이해하고 플로우를 시각화하며 분석한 덕분에 겉으로 드러나지 않던 핵심적인 문제점들을 정확히 발견할 수 있었다.

작은 불일치들이 전체 시스템의 기능에 얼마나 큰 영향을 미칠 수 있는지 다시 한번 깨달았고 이를 해결해야만 서비스의 완성도를 높일 수 있다는 확신을 가졌다.

발견한 AI 모델 플로우의 핵심 문제점들을 해결하기 위해 즉시 수정 작업에 착수했다.

일단 프론트엔드(sidebar-main.js)와 백엔드(SidebarProvider.ts)의 두 개 핵심 파일을 수정했다.

구체적으로는 프론트엔드에서 백엔드로 전송하는 명령어를 백엔드 generateCodeStreaming으로 통일했다.

그리고 전송되는 매개변수 이름도 prompt, modelType에서 백엔드와 일치하는 question, model_type으로 변경했다.

가장 중요했던 모델 타입 매핑 문제 해결을 위해 프론트엔드의 UI 모델 타입을 백엔드의 vLLM 모델 타입으로 정확하게 변환해주는 매핑 로직을 추가했다.

위 작업을 통해 code_completion과 같이 이전에 처리되지 않던 케이스들도 정상적으로 작동하도록 보완했다.

디버깅과 추적성을 높이기 위해 최종 스트리밍 요청 데이터에 원본 모델 타입과 매핑된 VLLM 타입을 함께 로깅하도록 개선했다.

문제점을 정확히 파악하는데 오랜 시간이 걸렸지만 수정 작업은 비교적 빠르게 진행될 수 있었다.

하지만 작은 매개변수 이름 하나, 명령어 하나가 전체 시스템의 동작을 좌우한다는 것을 다시 한번 실감했다.

타입 안전성을 확보하고 모델 타입에 대한 처리 로직을 보완하면서 코드의 견고함을 한층 더 높일 수 있었다고 생각한다.

Refactoring을 진행하며 frontend 영역의 일부 코드를 복구할 수 없게 날리며 일정부분 다시 구축하였다.

결과적으로는 더욱더 다듬어져 깔끔해지긴했지만 복구작업을 진행하며 이런 실수를 한 나에게 개인적으로 실망하기도 하였다.

Refactoring도 정확히 파악 후 신중히 진행해야함을 깨닫게 된 계기였을 수 있다.

사실상 개발 완료 기한이 약 1주일 가량 남았다.

1주일 안에 전반적인 문제/개선점들을 해결해 마무리할 수 있겠지...?ㅠ

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미 101~105일차 : 25.06.30(월)~04(금)

DS벨르 — Fri, 4 Jul 2025 15:38:56 +0900

이번 주는 오늘 오전 한컴 현직자분들께 진행할 중간 발표를 성공적으로 마무리하기 위한 핵심 작업인 AI 모델 연동 최적화에 집중했다.

지난주에 구현한 27개 온보딩 옵션 기반의 개인화 프롬프트 생성 로직이 AI 모델과 완벽하게 연동되는지 확인하는 것이 가장 중요했다.

실제 질문들을 Backend API로 요청하여 AI 모델의 응답이 VSCode Extension의 UI에 정확하고 빠르게 표시되는지 기능적 테스트를 반복했다.

특히, 사용자가 질문을 입력했을 때 AI가 코드를 생성하고 이를 실시간으로 스트리밍하여 VSCode Extension에 점진적으로 보여주는 과정에서 지연이 발생하지 않는지 성능적 테스트를 면밀히 진행했다.

vLLM 기반의 백엔드와 AI 백업 시스템 간의 자동 페일오버 기능도 함께 점검하며 어떤 상황에서도 안정적인 코드 생성이 이루어질 수 있도록 최적화 작업을 수행했다.

AI 모델 연동은 개인화 설정이 AI의 응답 품질에 실질적으로 반영되는지 확인하는 것이 중요했다.

실제 질문을 통해 테스트하며 AI의 응답이 사용자 인터페이스에 매끄럽게 표시되는지 확인하는 과정은 서비스의 핵심 가치를 증명하는 데 필수적이라고 생각했다.

발표를 앞두고 기능적 안정성과 성능 최적화에 모든 역량을 집중했습니다.

AI 모델 연동 테스트와 병행하여 사용자에게 가장 직관적이고 매끄러운 경험을 제공하기 위한 UI/UX 오류 해결에 많은 시간을 할애했다.

VSCode Extension의 사이드바, 주석 트리거, 실시간 자동완성, 컨텍스트 메뉴 등 다양한 UI 요소들이 예상치 못한 상황에서 오류를 발생시키거나 사용자 흐름을 방해하는 부분을 찾아내고 지속적으로 해결을 시도했다.

AI가 생성한 코드가 VSCode 편집기에 삽입될 때 레이아웃이 깨지거나 주석 트리거가 제대로 인식되지 않는 등의 사소하지만 사용자 경험에 치명적인 문제들을 꼼꼼히 점검하고 수정했다.

프론트엔드 팀과의 긴밀한 협업을 통해 발견된 버그를 빠르게 공유하고 사용자 시나리오 기반의 테스트를 반복하며 발표 시 시연 흐름이 끊기지 않도록 만전을 기했다.

온보딩 시스템을 통해 설정된 개인화 옵션이 VSCode Extension의 UI에 올바르게 반영되는지도 재확인하며, 사용자 맞춤형 경험이 시각적으로도 잘 드러나도록 노력했다.

아무리 훌륭한 AI 기능이라도 사용자가 직접 마주하는 UI/UX에서 불편함을 느끼면 의미가 퇴색된다는 것을 다시 한번 깨달았다.

발표를 앞두고 마지막까지 사용자 관점에서 서비스를 점검하며 사소한 오류 하나까지도 놓치지 않으려 노력했다.

오늘 오전 중간 발표를 성공적으로 진행하기 위해 이번 주 내내 진행했던 AI 모델 연동 최적화와 UI/UX 오류 해결 작업을 최종적으로 점검하고 시스템 안정화에 총력을 기울였다.

모든 기능이 예상대로 작동하는지 End-to-End 테스트를 다시 한번 수행하며 발표 시연에 필요한 모든 시나리오를 미리 연습했습니다.

HAPA 프로젝트의 핵심인 주석 기반 및 error 코드 인식과 수정하는 AI 코드 생성이 VSCode Extension에서 어떻게 구현되고 사용자에게 어떤 가치를 제공하는지 명확하게 보여줄 수 있도록 데모 흐름을 다듬었다.

Backend와 DB-Module, Frontend 간의 3-Way 동기화가 발표 중에도 원활하게 이루어지는지 확인했다.

중간 발표는 4주간의 노력을 보여주는 중요한 자리이기에 마지막까지 긴장의 끈을 놓을 수 없었습니다.

기술적인 완성도뿐만 아니라 우리가 만든 서비스가 어떤 가치를 제공하는지 효과적으로 전달하는 것이 중요하다는 것을 깨달았다.

이번 주 동안의 집중적인 작업과 점검을 통해 내가 얼마나 이 프로젝트에 진심인지 다시 한번 느꼈습니다.

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미 96~100일차 : 25.06.23(월)~27(금)

DS벨르 — Thu, 26 Jun 2025 18:28:20 +0900

AI 코딩 어시스턴트 프로젝트의 전체 시스템 아키텍처를 확정하고 이를 시각화하는 작업에 집중했다.

React, FastAPI, PostgreSQL, Redis 등 핵심 컴포넌트 간의 데이터 흐름과 상호작용을 명확히 정의하고 이를 Mermaid 다이어그램으로 상세하게 표현했다.

이 과정에서 각 컴포넌트의 역할과 책임 범위를 재정의하며 시스템 전체의 효율성과 확장성을 고려한 설계를 완성하는 데 주력했다.

프로젝트의 큰 그림을 그리고 이를 팀원들과 공유할 수 있는 명확한 청사진을 마련하는 중요한 단계라고 생각했다.

시스템 아키텍처를 시각화하는 과정은 각 컴포넌트의 역할과 연결성을 명확히 이해하는 데 큰 도움이 되었다.

복잡한 시스템을 한눈에 파악할 수 있도록 정리하는 작업은 개발 효율성을 높이고 추후 발생할 수 있는 문제점을 사전에 방지하는 데 필수적임을 다시 한번 깨달았다.

이번주 작업의 절반을 차지하는 사용자 개인화 온보딩 시스템 구현이다.

비즈니스 목표인 'AI 코딩 어시스턴트의 개인화 경험 극대화'와 '사용자 스킬 레벨별 맞춤형 코드 생성'을 위해 6단계에 걸쳐 총 27개의 세부 옵션을 제공하는 온보딩 플로우를 구상했다.

사용자의 Python 스킬 레벨, 코드 출력 구조, 설명 스타일, 프로젝트 컨텍스트 등 다차원적인 선호도를 반영하는 시스템이다.

기술적 도전과제로는 이 복잡한 온보딩 플로우의 관리, VSCode Extension ↔ Backend ↔ Database 간의 실시간 3-Way 동기화, 마이크로서비스 아키텍처 내에서의 관심사 분리, 미래 옵션 추가를 고려한 확장 가능한 설정 시스템 구축이다.

이를 위해 Backend API와 DB Module을 분리하는 마이크로서비스 아키텍처를 설계하고, PostgreSQL을 활용한 user_onboarding_settings 테이블 스키마를 정의했다.

사용자가 VSCode Extension에서 온보딩 설정을 변경하면, 이 변경사항이 DB Module에 저장되고 Backend API의 캐시를 무효화하며 최종적으로 로컬 VSCode 설정까지 업데이트되는 일련의 흐름을 단방향으로 설계하여 순환 의존성을 방지했다.

충돌 해결을 위해 Last-Write-Wins와 타임스탬프 기반 우선순위를 적용했으며 오프라인 환경에서도 설정 변경이 가능하도록 로컬 큐잉 후 온라인 시 일괄 동기화되는 로직을 추가했다.

그 후 구현된 온보딩 시스템의 품질을 확보하고 안정적인 운영을 위한 기반을 다지는 데 집중했다.

End to End 온보딩 테스트 자동화 스크립트를 작성하여 신규 사용자 등록부터 27개 옵션 설정, VSCode Extension 설정 동기화 확인, AI 코드 생성 품질 검증, 설정 변경 시 실시간 반영 테스트까지 완전한 온보딩 플로우를 자동으로 검증할 수 있도록 했다.

이를 통해 핵심 비즈니스 로직의 100% 테스트 커버리지를 목표로 삼았다.

그리고 중간중간 백엔드 API의 고도화와 동시에 프론트엔드 팀과의 연동 작업을 지속했다.
특히 generate API의 비동기 처리 방식에 대해 사용자에게 더 나은 경험을 제공하기 위한 방안을 모색했다.

AI 모델의 응답 시간이 길어질 경우를 대비하여 로딩 스피너나 진행 상태 메시지를 표시하는 등 사용자 피드백을 반영한 UI/UX 개선 아이디어를 공유했다.

또한, 백엔드에서 전달하는 응답 메시지의 가독성을 높여 프론트엔드에서 사용자에게 더 친절한 정보를 제공할 수 있도록 메시지 형식을 표준화하는 작업을 진행했다.

백엔드에서 아무리 잘 만들어도 사용자가 불편함을 느끼면 소용없다는 것을 다시 한번 느꼈다.

또한 프론트엔드의 기술적인 구현뿐만 아니라 실제 사용자의 입장에서 서비스를 바라보는 시야를 넓힐 수 있었다.

문제 발생 시 팀원들과 함께 고민하고 해결책을 찾아가는 과정이 정말 중요하다고 생각한다.

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미 86~95일차 : 25.06.09(월)~20(금)

DS벨르 — Sat, 21 Jun 2025 15:29:17 +0900

현재 진행 중인 프로젝트 내용의 제한적인 공개범위로 인해 코드나 구체적인 내용을 기재할 수 없어 이렇게 회고의 내용으로 작성한다.

6월 6일부터 AI 코딩 어시스턴트 프로젝트의 본격적인 시작을 알리며 백엔드 환경 구축에 집중했다.

특히 FastAPI와 MongoDB 연동 작업에 많은 시간을 할애했는데, 이전에 겪었던 어려움을 바탕으로 더욱 체계적인 접근을 시도했다.

초기 API 설계 단계부터 프론트엔드 팀과의 활발한 논의를 통해 명확한 API 명세를 확립하는 데 주력했고 핵심 기능인 코드 생성(generate) 엔드포인트 개발에 착수하며, AI 모델과의 연동을 고려한 API 구조를 잡는 데 심혈을 기울였다.

추후 프론트엔드 영역을 위해 API 연동 테스트를 진행하며 데이터 형식과 통신 방식에 대한 조율하며 백엔드에 집중했다.

환경 설정은 언제나 예상치 못한 변수가 많지만, 지난 경험을 통해 더 체계적으로 접근할 수 있었다.

초기 설계 단계부터 프론트엔드 팀과의 소통을 통해 API 명세를 명확히 하는 것이 중요하다고 느꼈고, 핵심 기능인 만큼 초기 설계가 중요하다고 생각했다.

저번주 금요일은 개인일정으로 인해 휴가를 썼기에 첫 멘토링에는 참석하지 못하였다.

(그래서 이번주에 진행한 멘토링을 시작하기에 앞서 긴장되더라...)

매주 멘토링이 금요일 오전으로 예정되어 있어 주간 팀 회의를 매주 목요일 오후에 진행하기로 하였다.

팀 정기회의를 통해 일주일간의 각 팀별 진행 상황 및 현황을 공유하고 다음 정기회의 때까지 진행할 작업의 목표를 설정했다.

백엔드를 주 작업으로 하고 프론트엔드도 타 팀원이 진행한 기능적인 요소들을 전달받으면 적절한 UI/UX에 맞게 조정하며 병합하는 방식으로 진행하였다.

어느정도 1차적인 작업의 마무리가 보일 때 Git에 업로드를 진행하던 중 발생한 브랜치 병합 충돌 문제를 해결하는 데 시간을 보냈다.

이 과정에서 Git 숙련도가 큰 도움이 되었다.

데이터베이스와의 연동을 위해 타 팀원이 작성한 DB 모듈을 넘겨받아 별도의 마이크로 서버로 백엔드와 연결하였다.

백엔드에는 데이터 유효성 검사 로직을 추가하고 발생 가능한 오류 상황에 대한 디버깅 작업을 진행하여 안정성을 높였다.

그 후 개발된 백엔드 API와 프론트엔드 UI 간의 통합 테스트를 진행하며 CORS 문제나 데이터 형식 불일치 등 기술적인 난관들을 해결했다.

또한, AI 코딩 어시스턴트의 코드 생성 로직을 정교하게 다듬고, API 응답 속도 및 전반적인 시스템 성능 최적화를 위한 코드 리팩토링을 병행하며 Readme.md 파일도 각 영역별로 꾸준히 수정하였다

주간 프로젝트 검토를 통해 다음 스프린트의 목표와 태스크를 구체화하며, 백엔드 개발의 진척도와 남은 과제들을 명확히 제시했다.

Git 충돌은 개발 과정에서 흔히 겪는 일이지만, 버전 관리의 중요성을 다시 한번 깨달았다.

데이터베이스는 우리 프로젝트의 페르소나 구현을 위해 중요하다는 생각이 들었다.

내가 구현한 백엔드와 프론트엔드가 유기적으로 작동하는 것을 보니 뿌듯했고, 통합 테스트는 예상치 못한 버그를 발견하고 사용자 경험을 개선하는 데 필수적인 과정임을 다시 한번 느꼈다.

특히, 사용자가 만족할 만한 서비스를 제공하기 위해서는 UI/UX 기능 구현뿐만 아니라 성능 최적화도 중요하며, 매주 진행 상황을 점검하고 다음 계획을 세우는 것이 프로젝트를 성공적으로 이끄는 데 큰 도움이 된다는 것을 깨달았다.

개발뿐 아니라 전반적인 문서 관리 및 일정 조율도 진행하고 있어 신경써야할 것이 많아 집에 들어가면 너무 지친다.

특히 이번 프로젝트를 진행하며 추후 채용에 PM이나 PO로 직무에 지원해봐야겠다라는 생각이 들기도 한다.
프로젝트를 전반적으로 파악하며 조율한다는게 쉽지않은 일임을 너무 깨닫고 있기에 개발직군 뿐 아니라 PM/PO 직군에 계신 분들도 정말 리스펙.....

[스나이퍼팩토리] 한컴AI아카데미 82~85일차 : 25.06.02(월)~05(목)

DS벨르 — Fri, 6 Jun 2025 18:30:43 +0900

이번주는 최종 확정 배정된 팀프로젝트의 기획을 시작으로 프로젝트가 시작되었다.

내가 참여하는 프로젝트는 AI coding Assistant이다.

해당 프로젝트에서 BE 전반과 FE 컨트롤을 맡기로 했다. 기존에 진행 중인 공모전 프로젝트와 병행으로 인해 굉장히 바빠질 것으로 예상되고 있다.

일정 컨트롤을 최대한 하며 진행해야할 것이다. 큰 문제는 없길 바라며...

원래 2주차에 시작할 계획이었으나 타이트한 개발일정으로 기본 구축을 한주 빨리 시작하기로 결정하고, 작업을 시작하였다.

해당 프로젝트에서 전반적인 문서관리도 진행하고 있기에 기획서나 개발계획서와 같은 문서들을 취합하고 정리하며, 팀장을 서포트하고 있다.

기획서 작성이 마무리 되어가는 것 같아 개발환경 구축을 시작하였고 진행내용은 아래와 같다.

1. 개발 환경 구축 (Python & FastAPI)

Python 3.12.7 환경 구성 완료 (3.8+ 호환성 보장)
가상환경(venv) 및 패키지 관리 체계 수립

python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

주요 설치 패키지:

FastAPI==0.110.1
uvicorn==0.29.0
pydantic-settings==2.2.1
python-dotenv==1.0.1

2. 프로젝트 아키텍처 구성

ai-coding-assistant/
├── app/
│   ├── __init__.py
│   ├── main.py        # FastAPI 앱 엔트리포인트
│   ├── schemas.py     # Pydantic 데이터 모델
│   └── config.py      # 환경변수 관리
├── tests/
├── .env               # 환경설정
├── requirements.txt
└── README.md          # 프로젝트 가이드

3. 핵심 API 설계 (OpenAPI 3.0 표준)

엔드포인트	메소드	기능	요청 예시
/api/v1/code/generate	POST	코드 생성	{"prompt": "파이썬 REST API 구현", "context": "현재 파일 내용"}
/api/v1/code/complete	POST	코드 자동완성	{"partial_code": "def calculate_sum(", "cursor_pos": 15}

4. 주요 개발 성과

초기 기능 구현

# 더미 응답 생성 예시
@app.post("/api/v1/code/generate")

async def generate_code(request: CodeGenerationRequest):
    return {
        "generated_code": f"# Generated code for: {request.prompt}",
        "confidence": 0.85
    }

예외 처리 시스템

@app.exception_handler(RequestValidationError)

async def validation_exception_handler(request, exc):
    return JSONResponse(
        status_code=422,
        content={"detail": "Invalid request format"}
    )

5. 문서화 진행 현황

Swagger UI 자동 생성 완료 (http://localhost:8000/docs)
API 응답 구조 표준화

{
  "status": "success",

  "data": {
    "generated_code": "print('Hello World')"
  },

  "metadata": {
    "processing_time": 0.25
  }
}

6. 향후 개선 계획

모델 서빙 인프라 연동 (vLLM → DeepSeek Coder 6.7B)
요청 처리 파이프라인 최적화
분산 처리를 위한 Celery 연동
Prometheus/Grafana 모니터링 시스템 구축

현재 진행률: 백엔드 기본 골격 완성 (API 설계 70%, 기능 구현 40%, 문서화 60%)
핵심 성과: 개발 생산성 향상을 위한 기반 인프라 구축 및 확장 가능한 구조 설계

다음주의 BE 개발 계획은 아래와 같다.

1. AI 모델 로딩 및 추론 코드 구조화 (inference.py 모듈 연동 준비, 더미 모델 사용 가능)

2. /generate 엔드포인트 기능 구현 시작 (요청 데이터 파싱, AI 모델 호출 부분 스켈레톤)

3. 요청 데이터 유효성 검사 로직 추가 (FastAPI Pydantic 활용)

4. /generate API 부분 테스트 코드 작성 및 실행 (단위 테스트)

정기회의는 매주 금요일 오전에 진행할 예정이기에 사실상 이 프로젝트의 주별 마감 요일은 목요일이다.

그래서 중간 작업 현황 체크를 위한 간단 회의는 월요일 오후로 예정되어 있다.

난 이 프로젝트를 통해 AI를 완벽히 다루지는 못하더라도 경험하며 활용할 수 있게 성장하고 싶다.

물론 결과물은 완벽하게 마무리 되길 바라며..ㅎ

[스나이퍼팩토리] 한컴AI아카데미 77~81일차 : 25.05.26(월)~30(금)

DS벨르 — Fri, 30 May 2025 15:08:16 +0900

이번주에는 28일 수요일에 정보처리기사 2회차 필기 시험이 있어 공결로 강의에 불참하였다.

기출문제 풀이 시 3과목이 점수가 나오질 않아 합격에 간당간당하여 너무 걱정되었다.

이번주는 트랜스포머 기반 모델 실습이 주로 이뤄졌다. 기존과 달리 대규모 텍스트까지 처리가 가능한 모델이기 때문에 중요한 실습이라고 생각한다.

강의 내용 및 요약 정리

1. 트랜스포머(Transformer) 기반 기계번역 실습

A. 트랜스포머란?

자연어 문장 내 모든 단어쌍의 관계를 한 번에 파악하는 딥러닝 모델입니다.
기존 RNN/LSTM과 달리 병렬처리가 가능하고, 긴 문장도 효과적으로 처리합니다.
번역, 요약, 질의응답 등 다양한 NLP 작업의 표준 구조입니다.

B. 실습 흐름

1) 데이터 준비 및 전처리

# 영어-스페인어 병렬 문장 데이터 다운로드
path_to_file = tf.keras.utils.get_file('spa-eng.zip', origin='http://storage.googleapis.com/download.tensorflow.org/data/spa-eng.zip')

# 파일 읽기 및 정제 함수
def preprocess_sentence(w):
    w = w.lower().strip()
    w = re.sub(r"([?.!,¿])", r" \1 ", w)
    w = re.sub(r'[" "]+', " ", w)
    w = re.sub(r"[^a-zA-Z?.!,¿]+", " ", w)
    
    return ' ' + w.strip() + ' '

설명: 문장을 소문자로 변환, 불필요한 기호/공백 제거, 시작/종료 토큰 추가

2) 토큰화 및 패딩

from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

tokenizer = Tokenizer(filters='', oov_token='<unk>')
tokenizer.fit_on_texts(sentences)

sequences = tokenizer.texts_to_sequences(sentences)

padded_sequences = pad_sequences(sequences, padding='post')

설명: 각 단어를 숫자(토큰)로 변환, 길이 맞춤(패딩)

3) 포지셔널 인코딩

def positional_encoding(position, d_model):
    angle_rads = get_angles(np.arange(position)[:, np.newaxis], np.arange(d_model)[np.newaxis, :], d_model)

    pos_encoding = np.zeros(angle_rads.shape)
    pos_encoding[:, 0::2] = np.sin(angle_rads[:, 0::2])
    pos_encoding[:, 1::2] = np.cos(angle_rads[:, 1::2])
    
    return tf.cast(pos_encoding, dtype=tf.float32)

설명: 단어 순서 정보를 벡터에 더해줌

4) 멀티헤드 어텐션 레이어

class MultiHeadSelfAttentionBlock(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads):
        super().__init__()

        self.mha = tf.keras.layers.MultiHeadAttention(num_heads=num_heads, key_dim=d_model//num_heads)
        self.norm = tf.keras.layers.LayerNormalization(epsilon=1e-6)

    def call(self, x, mask=None):
        attn_output = self.mha(x, x, x, attention_mask=mask)

        return self.norm(x + attn_output)

설명: 여러 '관점'에서 문장 내 단어 관계를 파악

5) 인코더-디코더 구조

class Encoder(tf.keras.layers.Layer):
    def __init__(self, num_layers, d_model, num_heads, dff):
        self.enc_layers = [EncoderLayer(d_model, num_heads, dff) for _ in range(num_layers)]

    def call(self, x, mask):
        for layer in self.enc_layers:
            x = layer(x, mask)

        return x

설명: 인코더는 입력 문장을 벡터로 요약, 디코더는 이를 바탕으로 번역문 생성

6) 학습 루프

for epoch in range(EPOCHS):
    for (batch, (inp, tar)) in enumerate(dataset):
        dec_input = tar[:, :-1]

        with tf.GradientTape() as tape:
            predictions = transformer([inp, dec_input])

            loss = loss_function(tar[:, 1:], predictions)

        gradients = tape.gradient(loss, transformer.trainable_variables)

        optimizer.apply_gradients(zip(gradients, transformer.trainable_variables))

설명: 입력-출력 쌍을 반복 학습, 손실 최소화

2. BERT 파인튜닝 실습

A. BERT란?

대규모 텍스트로 사전학습된 트랜스포머 기반 모델
다양한 언어 작업(감성분류, 질의응답 등)에 소량 데이터만 추가 학습(파인튜닝)하면 높은 성능

B. 실습 흐름

1) 데이터 준비 및 분할

texts = [
    "이 영화 정말 재미있어요! 강력 추천합니다.",
    "배우들 연기가 너무 좋았고 스토리도 탄탄해요.",
    # ... (생략)
]
labels = [1, 1, 0, 0, ...]

train_texts, test_texts, train_labels, test_labels = train_test_split(texts, labels, test_size=0.2)

설명: 텍스트와 라벨(긍정/부정) 데이터 준비, 학습/평가용 분리

2) BERT 토크나이저 및 모델 불러오기

from transformers import BertTokenizerFast, BertForSequenceClassification

tokenizer = BertTokenizerFast.from_pretrained('bert-base-multilingual-cased')

model = BertForSequenceClassification.from_pretrained('bert-base-multilingual-cased', num_labels=2)
model.to(device)

설명: 사전학습된 BERT 모델과 토크나이저 불러오기

3) 데이터 전처리 (토큰화, 패딩)

train_encodings = tokenizer(train_texts, truncation=True, padding=True, max_length=128, return_tensors='pt')
test_encodings = tokenizer(test_texts, truncation=True, padding=True, max_length=128, return_tensors='pt')

설명: 텍스트를 BERT 입력(숫자 시퀀스, 마스크)으로 변환

4) PyTorch Dataset/DataLoader 구성

class SentimentDataset(Dataset):
    def __init__(self, encodings, labels):
        self.encodings = encodings
        self.labels = labels

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]

        return item

    def __len__(self):
        return len(self.labels)

train_dataset = SentimentDataset(train_encodings, torch.tensor(train_labels))
train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True)

설명: 미니배치 단위로 데이터 공급

5) 파인튜닝(학습) 루프

optimizer = AdamW(model.parameters(), lr=5e-5)

for epoch in range(3):
    model.train()

    for batch in train_loader:
        optimizer.zero_grad()

        input_ids = batch['input_ids'].to(device)

        attention_mask = batch['attention_mask'].to(device)

        labels = batch['labels'].to(device)

        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)

        loss = outputs.loss
        loss.backward()

        optimizer.step()

설명: 사전학습된 BERT를 내 데이터에 맞게 추가 학습

6) 평가 및 예측

def predict_sentiment(text, model, tokenizer, device, max_length=128):
    model.eval()

    encoding = tokenizer([text], truncation=True, padding=True, max_length=max_length, return_tensors='pt')

    input_ids = encoding['input_ids'].to(device)

    attention_mask = encoding['attention_mask'].to(device)

    with torch.no_grad():
        outputs = model(input_ids, attention_mask=attention_mask)
        prediction_idx = torch.argmax(outputs.logits, dim=-1).cpu().item()

    return "긍정" if prediction_idx == 1 else "부정"

설명: 학습된 모델로 새 문장의 감성(긍정/부정) 예측

정리

트랜스포머 실습:
1. 데이터 전처리 → 토큰화/패딩 → 포지셔널 인코딩/어텐션 → 인코더-디코더 조립 → 학습 루프
2. 기계번역 등 다양한 NLP 작업에 적용

BERT 파인튜닝 실습:
1. 사전학습된 BERT 모델과 토크나이저 불러오기 → 내 데이터로 파인튜닝 → 감성분류 등 실전 적용
2. 소규모 데이터로도 높은 성능

오늘이 이 과정을 시작한지 정확히 4개월이 끝나는 날이다. 프로젝트 마무리까지 2개월이 채 안남은 시점이기도 하다.

이번달은 특히 더 정신없이 보낸거 같다는 생각이 든다.
공모전 프로젝트는 본격적으로 시작했지, 자격증은 간당간당하지, 한컴 프로젝트도 당장 다음주부터 시작하지, 채용 준비도 병행하지..

여러가지를 병행하고 있다보니 심리적으로 나도 모르게 지쳐가고 있지 않은가 싶기도 했다.

체력적으로도 다시 회복이 더뎌가고 있는건지 일주일째 헬스도 못가고 있다. (도저히 새벽에 일어날 수가 없었..ㅠ)

다음주엔 수액 한번 맞고 헬스도 하며 다시 달려갈 생각이다.

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미 72~76일차 : 25.05.19(월)~23(금)

DS벨르 — Fri, 23 May 2025 14:09:11 +0900

이번 주에는 자연어처리(NLP) 실습, RNN/LSTM, 그리고 트랜스포머 모델까지 다양한 딥러닝 구조와 코드를 접했다.

특히 트랜스포머 구조와 어텐션, 포지셔널 인코딩 등은 처음 접하는 개념이라 이해하는 데 시간이 많이 걸렸고,

코드 구현 과정에서 데이터 전처리(토큰화, 패딩, OOV 처리 등)와 모델 입력/출력 형태를 맞추는 부분에서 오류가 자주 발생했다.

트랜스포머의 각 블록(멀티헤드 어텐션, 인코더/디코더, 마스킹 등)이 어떻게 연결되는지 처음엔 전체 흐름이 잘 그려지지 않았다.

강의 내용 및 요약 정리

1. 자연어 처리(NLP) 기본 실습 (1-NLP.ipynb, nlpsilseub.ipynb)

텍스트 데이터 준비 및 전처리
- 영화 리뷰(긍정/부정) 등 텍스트와 라벨 데이터 준비
- 토크나이저로 단어를 정수 시퀀스로 변환, OOV(미등록어) 처리
- 시퀀스 길이 통일을 위한 패딩(pad_sequences) 적용

딥러닝 모델 구성
- Embedding 레이어: 각 단어를 의미 벡터로 변환
- Flatten 또는 GlobalAveragePooling1D로 벡터 펼침
- Dense(시그모이드)로 이진 감성 분류
- 모델 컴파일(optimizer, loss, metrics) 및 학습/평가

실전 팁
- 하이퍼파라미터(임베딩 차원, 배치, 에포크 등) 튜닝
- 데이터 양이 많을수록, 다양한 구조 실험이 중요
- 과적합 방지 위해 검증셋 분리, Dropout 등 적용 권장

2. 순환 신경망(RNN)과 LSTM 실습 (2-RNN.ipynb)

RNN 개념
- 시퀀스(순서 정보가 중요한 데이터) 처리를 위한 신경망
- 이전 입력의 정보를 기억(메모리)하며 순차적으로 처리

LSTM(Long Short-Term Memory)
- RNN의 장기 의존성 문제(기억력 부족) 해결
- 영화 리뷰, 뉴스 분류 등 시계열/텍스트 데이터에 강점

실습 내용
- Embedding → LSTM → Dense(softmax/sigmoid) 구조
- IMDB 영화 리뷰, 로이터 뉴스 분류 등 실습
- 학습/검증 손실 그래프, EarlyStopping 등 활용
- CNN+LSTM 조합: CNN으로 n-gram 특성 추출 후 LSTM으로 문맥 파악

Seq2Seq/어텐션 소개
- 입력 시퀀스를 다른 시퀀스로 변환(번역, 요약 등)
- 인코더-디코더 구조, Teacher Forcing, 어텐션 메커니즘 개념

3. 트랜스포머 모델 구조와 구현 (transformer-stepbystep.ipynb)

트랜스포머(Transformer)란?
- RNN 없이도 문장 내 단어 관계를 어텐션(Self-Attention)으로 파악
- 번역, 요약, 질의응답 등 다양한 NLP 작업에서 표준 모델

핵심 구성요소
- 입력 전처리: 텍스트→숫자 시퀀스, 패딩, 토크나이저
- 포지셔널 인코딩: 단어 순서 정보를 임베딩에 더함
- 멀티헤드 어텐션: 문장 내 모든 단어쌍 관계를 병렬로 계산
- 피드포워드 네트워크: 각 위치별 완전연결 레이어
- 인코더/디코더 스택: 인코더(입력 문장), 디코더(출력 문장) 각각 여러 층 쌓음
- 마스킹: 패딩, 미래 단어 가리기(룩어헤드 마스크)
- 최종 출력: 각 시점마다 다음 단어 예측

실습 흐름
1. 영어-스페인어 병렬 데이터셋 다운로드 및 전처리
2. 토크나이저로 시퀀스 변환, 패딩, 어휘집 크기 확인
3. tf.data.Dataset으로 배치 구성
4. 각 블록(Layer)별로 커스텀 클래스 구현
5. 전체 트랜스포머 모델 조립
6. 하이퍼파라미터 설정 후 학습
응용
- 기계번역, 챗봇, 요약, 질의응답 등
- 이후 BERT, GPT 등 대형 사전학습 모델의 기반

4. 실전 감성분석 실습 (nlpsilseub.ipynb)

작은 데이터셋으로 감성분석 모델 만들기
- 긍정/부정 영화리뷰 20개로 실습
- 토크나이저, 정수 인코딩, 패딩, 임베딩, Dense로 간단 모델
- 학습 후 새로운 리뷰에 대한 예측까지 실습
- 데이터가 적을 때 한계, 더 많은 데이터 필요성 강조

5. (참고) BERT, GPT 등 대형 사전학습 모델 실습 (0523-BERTGPT.ipynb)

파일 미열람/요약 불가
- 일반적으로 BERT, GPT 등은 트랜스포머 기반의 대형 언어모델
- 사전학습(Pretraining)과 파인튜닝(Fine-tuning)으로 다양한 NLP 작업에 활용

전체 흐름 및 학습 포인트

자연어 처리의 기본(텍스트→숫자, 임베딩, 감성분류)부터
시퀀스/시계열 데이터 처리(RNN, LSTM, CNN+LSTM, Seq2Seq)
최신 NLP의 표준 트랜스포머 구조(어텐션, 인코더-디코더, 마스킹 등)
까지 실습과 이론을 단계적으로 경험할 수 있습니다.

실습 내용

1. 데이터 준비 및 전처리

# 데이터 다운로드 및 전처리
path_to_zip = tf.keras.utils.get_file('spa-eng.zip', origin='http://storage.googleapis.com/download.tensorflow.org/data/spa-eng.zip')
path_to_file = os.path.dirname(path_to_zip)+"/spa-eng/spa.txt"

# 텍스트 정규화 함수
def preprocess_sentence(w):
    w = unicode_to_ascii(w.lower().strip())  # 소문자 변환 및 악센트 제거
    w = re.sub(r"([?.!,¿])", r" \1 ", w)    # 구두점 주변 공백 추가
    w = re.sub(r'[" "]+', " ", w)           # 중복 공백 제거
    w = re.sub(r"[^a-zA-Z?.!,¿]+", " ", w)  # 특수문자 제외 필터링
    return ' ' + w.strip() + ' '            # 시작/종료 토큰 추가

목적: 원시 텍스트를 모델이 처리 가능한 형태로 변환
핵심 과정:
- 유니코드 정규화 → 소문자 변환 → 구두점 처리 → 특수문자 제거
- 문장 시작/종료 토큰(<start>, <end>) 추가

2. 토큰화 및 패딩

def tokenize(lang):
    lang_tokenizer = Tokenizer(filters='', oov_token='<unk>')
    lang_tokenizer.fit_on_texts(lang)
    tensor = lang_tokenizer.texts_to_sequences(lang)
    return pad_sequences(tensor, padding='post')

# 영어/스페인어 별도 토크나이징
input_tensor, inp_lang_tokenizer = tokenize(inp_lang_raw)
target_tensor, targ_lang_tokenizer = tokenize(targ_lang_raw)

특징:
- OOV(Out-Of-Vocabulary) 토큰 <unk> 처리
- 시퀀스 길이 통일을 위해 패딩(padding='post')

3. 트랜스포머 아키텍처

3.1 포지셔널 인코딩

def positional_encoding(position, d_model):
    angle_rates = 1 / np.power(10000, (2 * (i//2)) / np.float32(d_model))
    return tf.concat([tf.sin(angles), tf.cos(angles)], axis=-1)

목적: 단어 순서 정보 주입
방식: 사인/코사인 함수 조합으로 위치별 고유 패턴 생성

3.2 멀티헤드 어텐션

class MultiHeadSelfAttentionBlock(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads):
        self.mha = MultiHeadAttention(num_heads=num_heads, key_dim=d_model//num_heads)
        self.norm = LayerNormalization(epsilon=1e-6)

    def call(self, x, mask=None):
        attn_output = self.mha(x, x, x, attention_mask=mask)
        return self.norm(x + attn_output)

기능: 병렬 어텐션 헤드로 다양한 문맥 관계 학습
특징: 레이어 정규화 및 잔차 연결 적용

4. 인코더-디코더 구조

# 인코더
class Encoder(tf.keras.layers.Layer):
    def __init__(self, num_layers, d_model, num_heads, d_ff):
        self.enc_layers = [EncoderLayer(d_model, num_heads, d_ff)
                          for _ in range(num_layers)]

# 디코더                          
class Decoder(tf.keras.layers.Layer):
    def __init__(self, num_layers, d_model, num_heads, d_ff):
        self.dec_layers = [DecoderLayer(d_model, num_heads, d_ff)
                          for _ in range(num_layers)]

계층 구조:
- 인코더: N개 셀프 어텐션 + FFN 레이어 스택
- 디코더: 2개 어텐션(마스크드 셀프 + 인코더-디코더) + FFN

5. 모델 학습

# 손실 함수 (패딩 무시)
def loss_function(real, pred):
    mask = tf.math.logical_not(tf.math.equal(real, 0))
    loss = loss_object(real, pred)
    mask = tf.cast(mask, dtype=loss.dtype)
    return tf.reduce_sum(loss * mask) / tf.reduce_sum(mask)

# 학습 루프
for epoch in range(EPOCHS):
    for (batch, (inp, tar)) in enumerate(dataset):
        dec_input = tar[:, :-1]  # Teacher Forcing
        with tf.GradientTape() as tape:
            predictions = transformer([inp, dec_input])
            loss = loss_function(tar[:, 1:], predictions)

핵심 기법:
- Teacher Forcing: 실제 정답을 디코더 입력으로 사용
- 패딩 마스킹: 의미 없는 패딩 토큰 무시
- 옵티마이저: Adam with custom learning rate

6. 주요 하이퍼파라미터

파라미터	값	설명
d_model	128	임베딩 차원
num_heads	4	어텐션 헤드 수
num_layers	2	인코더/디코더 층 수
d_ff	512	FFN 은닉층 크기
dropout_rate	0.1	과적합 방지

어려운 개념(어텐션, 포지셔널 인코딩 등)은 그림과 공식, 예시 코드를 반복해서 보며 이해하려 노력했다.
(그럼에도 이해하기엔 쉽지 않았지만....ㅎ)

기초적인 텍스트 분류부터 RNN/LSTM, 그리고 트랜스포머까지 자연어처리의 주요 흐름을 실습을 통해 경험할 수 있었다.

트랜스포머 구조의 핵심 원리(어텐션, 인코더-디코더, 마스킹 등)를 직접 구현해보며, 최근 NLP 모델의 동작 원리를 조금씩 이해하게 되었다.

아직 익숙하지는 않지만, 앞으로도 다양한 실습과 예제 코드를 반복해서 연습해보고 싶다.

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.

[스나이퍼팩토리] 한컴AI아카데미 67~71일차 : 25.05.12(월)~16(금)

DS벨르 — Fri, 16 May 2025 17:12:22 +0900

이번주부터 본격적인 ML/DL 파트가 시작되었다.

일요일 밤에 오랜만의 불면증으로 인해 한숨도 못자고 월요일을 시작해버렸다. 도저히 잠이 들지 않아 헬스장을 오픈런해서 다녀왔고,
저녁땐 매주 2번 러닝 뛰기로한 날이기에 러닝까지 일부러 빼먹지 않고 뛰어 신체적인 피로도를 높였다.

그래야만 기절하듯 잠들 수 있을 것 같아서 말이다.

이번주 시작부터 꼬여버려 굉장히 긴 일주일이 되어가고 있는 느낌이다.

강의 내용 및 요약 정리

1. 데이터 전처리의 중요성

정의: 원시 데이터를 분석 및 모델링에 적합한 형태로 가공하는 과정.
필요성: 현실 데이터는 결측치, 이상치, 중복, 불일치 등 다양한 문제를 포함.
모델 성능 저하, 잘못된 결론 초래 가능.
데이터 품질 개선과 모델 성능 향상에 필수적임.

주요 전처리 단계:
결측치 처리: 삭제, 평균/중앙값 대체, 예측값 대체 등
이상치 처리: 제거, 대체, 변환(로그 등), 이상치에 강건한 모델 사용
중복 데이터 처리: 중복 행 탐지 및 제거
데이터 구조 및 특성 파악, 도메인 이해, 시각화 등

실전 팁: 데이터 특성·문제에 따라 적절한 전처리 방법을 선택해야 하며, 효과적인 전처리는 머신러닝 프로젝트 성공의 핵심.

2. 데이터 스케일링 (Scaling)

목적: Feature(특성) 값의 범위를 맞춰 거리 기반 모델(KNN, SVM 등)이나 경사하강법 기반 모델(회귀, 신경망 등)의 학습 효율과 성능을 높임.
주요 기법:
표준화(Standardization): 평균 0, 표준편차 1로 변환. 정규분포에 가깝게 만듦. 이상치에 덜 민감.
Min-Max 스케일링: 0~1 범위로 변환. 값의 범위를 엄격하게 제한할 때 유용. 이상치에 민감.
Robust 스케일링: 중앙값과 IQR(사분위 범위) 사용. 이상치에 강건.
MaxAbs 스케일링: 각 특성의 절댓값 최대치를 기준으로 -1~1 범위로 변환. 희소 데이터에 적합.

적용 시점: 거리 기반/경사하강법 기반 모델, Feature 간 범위 차이가 큰 경우.
불필요/주의: 트리 기반 모델(랜덤포레스트 등)에는 필요 없음.
Data Leakage 방지: 반드시 Train 데이터로만 fit, Test 데이터에는 transform만 적용해야 함.

3. 데이터 변환 (Transformation)

목적: 데이터 분포(왜도, 비대칭성)를 정규분포에 가깝게 조정, 분산 안정화, 이상치 영향 감소, 모델 가정 충족.
주요 기법:
로그 변환: 오른쪽 꼬리(Positive Skew) 데이터에 효과적. 값이 0 또는 음수면 log(x+1) 등 사용.
제곱근 변환: 로그 변환보다 약한 효과. 양수 데이터에 사용.
거듭제곱 변환(Power Transformation):
Box-Cox: 양수 데이터에 적용, 최적 람다값 자동 탐색.
Yeo-Johnson: 음수, 0, 양수 모두 처리 가능.

적용 순서: 변환 → 스케일링(보통), 모델 요구사항과 데이터 분포 확인 후 결정.
Data Leakage 방지: 변환도 Train 데이터로 fit, Test 데이터에는 transform만 적용.

4. 범주형 데이터와 인코딩

범주형 데이터: 유한한 그룹/범주로 구분되는 데이터(예: 성별, 국가, 등급 등).
유형:
명목형(Nominal): 순서 없음(예: 색상, 혈액형)
순서형(Ordinal): 순서 있음(예: 학점, 만족도)

인코딩 필요성: 대부분의 머신러닝 모델은 수치형 입력만 처리 가능하므로, 범주형 데이터를 수치형으로 변환해야 함.
주요 인코딩 기법:
레이블 인코딩(Label Encoding): 각 범주를 정수로 매핑. 순서형 데이터나 트리 기반 모델에 적합. 명목형 데이터에는 순서 왜곡 주의.
원-핫 인코딩(One-Hot Encoding): 각 범주를 이진 벡터로 변환. 명목형 데이터에 적합. 범주 수가 많으면 차원 증가/희소성 문제 주의.
순서형 인코딩(Ordinal Encoding): 명확한 순서가 있는 데이터에 직접 순서를 지정해 정수로 변환.

적용 시 주의:
데이터 유형(명목/순서형) 정확히 파악
훈련/테스트 데이터 분리 후 인코딩, fit은 훈련 데이터에만, transform은 전체에 적용
차원 증가, 정보 손실, 모델 특성 등 고려

5. 실전 적용 및 코드 예시

각 기법별로 pandas, sklearn 등 라이브러리 활용 코드 예시 다수 포함
결측치/이상치/중복 처리, 스케일링, 변환, 인코딩 등 실제 데이터에 바로 적용 가능한 코드 제공
실습 시 데이터 분포 확인, 모델 요구사항 파악, Data Leakage 방지, 여러 기법 비교 후 최적 선택 권장

6. 결론

데이터 전처리는 머신러닝/데이터 분석의 성패를 좌우하는 필수 단계
데이터의 문제(결측치, 이상치, 중복, 범주형 등)를 해결하고, 모델과 데이터 특성에 맞는 스케일링·변환·인코딩 기법을 적절히 선택해 적용해야 함
모든 전처리 과정에서 Data Leakage를 반드시 방지해야 하며, 실전에서는 여러 기법을 비교·실험해 최적의 결과를 도출하는 것이 중요함

7. 선형 회귀 모델

개념: 독립 변수(들)와 종속 변수 간의 선형 관계를 수식으로 모델링하여 예측하는 가장 기본적인 통계/머신러닝 기법.
단순 선형 회귀: 독립 변수 1개, 종속 변수 1개.
모델: y=wx+by=wx+b
오차 최소화: 평균 제곱 오차(MSE) 사용, 최소 제곱법(OLS)으로 최적의 w, b 계산.
scikit-learn으로 간단히 구현 가능.

다중 선형 회귀: 독립 변수가 여러 개인 경우.
모델: y=β0+β1x1+⋯+βpxp+ϵy=β0+β1x1+⋯+βpxp+ϵ
각 계수는 다른 변수 고정 시 해당 변수의 영향력 의미.

실습: 데이터 준비, 모델 학습/예측/평가(MSE, R²), 회귀 계수 해석 등.
고려사항:
선형성, 오차 독립성, 등분산성, 오차 정규성, 다중공선성 부재 등 가정 필요.
범주형 변수는 원-핫/레이블 인코딩 필요.
과적합 방지 위해 L1(Lasso), L2(Ridge) 규제 사용 가능.

8. 로지스틱 회귀 모델

개념: 분류 문제(이진/다항)에 사용되는 지도학습 알고리즘. 입력이 특정 범주에 속할 확률을 예측.
이진 로지스틱 회귀:
시그모이드 함수로 0~1 확률 출력, 0.5 기준으로 분류.
비용 함수: 로그 손실(교차 엔트로피), 경사하강법으로 최적화.
scikit-learn으로 구현 가능.

다항 로지스틱 회귀:
소프트맥스 함수로 여러 클래스 확률 출력.
손실 함수: 다중 클래스 교차 엔트로피.
scikit-learn에서 multi_class='multinomial' 옵션 사용.

모델 평가: 정확도, 정밀도, 재현율, F1, AUC-ROC, 혼동행렬 등 다양한 분류 지표 활용.

9. 소프트맥스 회귀 모델

개념: 다중 클래스 분류 문제 해결을 위한 모델. 로지스틱 회귀의 일반화.
소프트맥스 함수: 입력 벡터를 각 클래스별 확률로 변환, 합은 1.
교차 엔트로피 손실: 예측 확률 분포와 실제(원-핫) 분포 간 차이 측정.
학습: 경사하강법으로 파라미터(W, b) 업데이트.
Python 구현:
데이터 원-핫 인코딩, 소프트맥스/교차엔트로피 함수 직접 구현.
예측, 정확도 평가, 손실 시각화 등 실습.

활용: 이미지 분류, 텍스트 분류, 제품 카테고리 분류 등.

10. 모델 평가

중요성: 모델 성능을 객관적으로 측정, 개선 방향 제시, 최종 모델 선택 기준 제공.
주요 지표:
정확도(Accuracy): 전체 중 정답 비율.
혼동행렬(Confusion Matrix): TP, TN, FP, FN 등 오류 유형 파악.
정밀도(Precision), 재현율(Recall), F1-score: 불균형 데이터에서 중요.
ROC/AUC: 분류 임계값 변화에 따른 성능 시각화, 종합 평가.
로그 손실(Log Loss): 확률 예측의 정확도 평가.

평가 과정:
데이터 분할(훈련/검증/테스트), 교차검증(K-fold), 지표별 코드 예시 포함.

11. 신경망 소개

개념: 인간 뇌의 뉴런 구조를 모방한 계층적 기계학습 모델.
구성요소: 입력, 가중치, 편향, 활성화 함수(시그모이드, ReLU, Tanh 등), 출력.
뉴런 작동: 입력×가중치+편향 → 활성화 함수 → 출력.
다층 퍼셉트론(MLP): 여러 은닉층 포함, 비선형 활성화 함수로 복잡한 패턴 학습.
학습: 손실 함수(MSE, 교차엔트로피) 최소화, 경사하강법과 역전파로 가중치/편향 업데이트.
간단 구현: Python/NumPy로 퍼셉트론, MLP 순전파 코드 예시 제공.
향후 학습: CNN, RNN, 딥러닝 프레임워크, 고급 최적화 기법 등.

12. 퍼셉트론

개념: 가장 단순한 인공 신경망, 이진 분류 문제에 사용.
구조: 입력, 가중치, 편향, 계단(스텝) 활성화 함수.
학습 알고리즘: 오차 기반 가중치/편향 반복 업데이트(에포크 단위).
한계: 선형 분리 문제만 해결 가능(XOR 등 비선형 분리 불가).
확장: 다층 퍼셉트론(MLP)으로 한계 극복, 비선형 문제 해결.
활용: 간단 논리회로, 이진 분류, MLP 구성요소.

13. MLP (다층 퍼셉트론)

정의: 여러 층(입력, 은닉, 출력)의 퍼셉트론을 쌓은 심층 신경망.
구성요소: 층, 노드, 가중치/편향, 활성화 함수(시그모이드, ReLU, Tanh, Softmax).
작동 원리:
순전파: 입력→출력까지 연산.
역전파: 오차를 각 층으로 전달, 경사하강법으로 파라미터 업데이트.

PyTorch 구현: 모델 정의, 손실함수/옵티마이저 설정, 학습/평가 코드 예시.

장점: 비선형 문제 해결, 다양한 문제 적용, 심층 학습의 기본.
한계: 과적합, 경사소실, 많은 데이터 필요, 해석 어려움.

14. 역전파(Backpropagation)

개념: 신경망 학습의 핵심 알고리즘. 오차를 출력→입력 방향으로 전파해 각 층의 가중치/편향을 효율적으로 업데이트.
수학적 원리:
순전파: 입력→출력 계산.
손실 함수: 예측값-실제값 오차 측정(MSE, 교차엔트로피 등).
경사하강법: 손실 함수의 기울기(gradient) 계산, 파라미터 업데이트.
연쇄법칙(Chain rule)으로 각 층의 기울기 계산.

알고리즘 단계:
1. 순전파
2. 출력층 오차 계산
3. 역전파로 각 층 오차 계산
4. 기울기 계산
5. 가중치/편향 업데이트

NumPy 코드 예시: 2층 신경망 순전파/역전파/업데이트/학습 과정 구현.
의의: 심층 신경망 학습의 필수, 자동 미분 프레임워크의 기반.

실습 내용

기존 강사님 사정상 새로운 강사님이 월요일만 담당하셔서 오셨는데, 전혀 강의준비가 되어 있지 않다는 느낌을 받을 정도로 심각했다.

그래서 해당 부분에 대한 의견을 운영진에게 전달했고, 빠른 피드백으로 반영되었다.

전혀 공부해보지 않은 분야이기에 이해하는데도 시간이 꽤 걸리고 머리속에 남기기도 쉽지 않은 상태이다.

금요일인 오늘은 오전에 AI Expo에 참석했다. 여러 기업의 여러 AI기술 활용한 것을 설명들으며 기술 활용에 대한 시야를 확장하려 노력했다. 시간관계상 세션이나, 강연에는 참여할 수 없어서 최대한 참가기업이나 단체를 둘러보는 고 설명듣는 것으로 목표를 잡고 참석하였다.

다음달에 열릴 다른 AI관련 행사에도 참석해볼 생각이다.

[스나이퍼팩토리] 한컴AI아카데미 65~66일차 : 25.05.07(수)~09(금)

DS벨르 — Fri, 9 May 2025 15:11:52 +0900

이번주도 월,화 연휴로 인해 수요일부터 다시 일정이 시작되었다.

어제까지 FastAPI(Web Server)강의가 진행되었고, 금요일인 오늘부터 새 강의인 Mashine Learning / Deep Learning 이 시작되었다.

사실상 이 과정의 핵심이 오늘부터 약 한달간 진행하는 것이다. 이것을 위해 약 3개월간 달려온 것이라고 해도 무방하다.

한달동안의 강의로 다음달에 프로젝트가 가능할지 매우 의문은 든다..

강의 내용 및 요약 정리

라우터분리 개요

FastAPI는 기본적으로 하나의 main.py 파일에 모든 API 경로를 정의할 수 있는 기능을 제공한다.
예시 API 경로: /users, /items, /posts 등.

이러한 구조는 작은 프로젝트에서는 유용하지만, 프로젝트가 커질수록 복잡성이 증가하게 된다.
라우터분리는 이러한 문제를 해결하기 위한 방법으로, API를 기능별로 파일로 나누어 관리하는 것을 의미한다.

라우터분리의 필요성

프로젝트가 커지면 수백 개의 API가 생성될 수 있다.
이로 인해 API 관리가 매우 복잡해진다.
예를 들어, API의 수가 많아질수록 코드의 가독성이 떨어지고, 유지보수가 어려워진다.

따라서, 라우터를 분리하여 관리하는 것이 효율적이다.

라우터분리 정의

라우터(router)는 API의 경로를 관리하는 역할을 한다.
라우터를 기능별로 파일로 나누어 관리하는 것이 라우터분리의 핵심이다.
이를 통해 각 기능에 대한 코드가 모듈화되어, 관리와 유지보수가 용이해진다.

라우터분리의 장점

라우터분리의 주요 장점은 다음과 같다:
가독성 향상: 코드가 모듈화되어 가독성이 높아진다.
유지보수 용이: 각 기능별로 파일이 나누어져 있어, 수정 및 업데이트가 용이하다.
협업 효율성: 여러 개발자가 동시에 작업할 수 있어, 팀워크가 향상된다.
확장성: 새로운 기능 추가 시 기존 코드에 미치는 영향을 최소화할 수 있다.

Swagger UI와 ReDoc 소개

FastAPI는 API를 만들면 자동으로 문서화를 해주는 기능이 있다.
사용자는 별도의 설정 없이도 브라우저에서 바로 API 테스트를 할 수 있는 편리함이 있다.
Swagger UI와 ReDoc은 FastAPI의 문서화 도구로, 각각의 특징과 장점이 있다.
이 도구들은 API 문서화의 효율성을 높이고, 개발자와 사용자 간의 소통을 원활하게 해준다.

Swagger UI의 작동 원리

FastAPI는 Pydantic 모델, Path/Query/Body 파라미터의 타입 힌트, docstring, status code 등을 기반으로 자동 문서를 생성한다.
이러한 요소들은 API의 구조와 기능을 명확하게 설명하는 데 중요한 역할을 한다.
Swagger UI는 사용자가 API를 쉽게 이해하고 테스트할 수 있도록 돕는 인터페이스를 제공한다.
문서화 과정에서 발생할 수 있는 오류를 최소화하고, 일관된 형식을 유지하는 데 기여한다.

ReDoc의 작동 원리

ReDoc은 FastAPI의 또 다른 문서화 도구로, Swagger UI와 유사한 기능을 제공한다.
FastAPI는 API를 만들면 자동으로 문서화를 해주며, ReDoc은 이를 시각적으로 잘 표현하는 데 중점을 둔다.
ReDoc은 사용자 친화적인 인터페이스를 통해 API 문서를 쉽게 탐색할 수 있도록 설계되어 있다.
이 도구는 API의 복잡한 구조를 명확하게 보여주어, 사용자들이 이해하기 쉽게 돕는다.

커스터마이징 가능성

FastAPI의 Swagger UI와 ReDoc은 커스터마이징이 가능하다.
사용자는 필요에 따라 문서의 스타일이나 내용을 조정할 수 있는 유연성을 제공받는다.
이러한 커스터마이징 기능은 특정 요구사항이나 브랜드 이미지에 맞춰 API 문서를 최적화할 수 있게 해준다.
개발자는 API 문서화의 일관성을 유지하면서도, 개인화된 요소를 추가할 수 있는 기회를 갖는다.

Swagger와 ReDoc 비교

Swagger와 ReDoc은 각각의 장단점이 있으며, 사용자의 필요에 따라 선택할 수 있다.
Swagger UI는 인터랙티브한 테스트 기능이 뛰어나며, 사용자가 API를 직접 시도해볼 수 있는 환경을 제공한다.
반면, ReDoc은 시각적 표현에 강점을 가지며, 복잡한 API 문서를 보다 쉽게 이해할 수 있도록 돕는다.
두 도구 모두 FastAPI의 자동 문서화 기능을 활용하지만, 사용자의 선호도에 따라 선택이 달라질 수 있다.

의존성주입 개요

의존성주입(Dependency Injection)은 어떤 함수가 외부의 설정이나 객체, 기능(예: DB 연결, 사용자인증 등)을 직접 만들지 않고 외부에서 주입받아 사용하는 방식이다.
이 방식은 코드의 유연성과 재사용성을 높이는 데 기여한다.
의존성주입을 통해 결합도를 낮추고, 테스트 용이성을 증가시킬 수 있다.
FastAPI와 같은 프레임워크에서는 의존성주입을 간단하고 강력하게 지원한다.

FastAPI에서의 의존성주입

FastAPI는 의존성주입을 매우 간단하게 구현할 수 있도록 설계되어 있다.
이를 통해 개발자는 복잡한 설정 없이도 필요한 의존성을 쉽게 관리할 수 있다.
FastAPI에서 의존성주입을 사용하면, 코드의 가독성과 유지보수성이 향상된다.
의존성주입을 통해 모듈화된 코드를 작성할 수 있으며, 이는 팀 작업 시에도 유리하다.

의존성주입 사용법

FastAPI에서 의존성주입을 사용하기 위해서는 **함수 매개변수로 Depends()**를 사용해야 한다.
Depends()는 필요한 의존성을 자동으로 주입해 주는 역할을 한다.
이 방식은 개발자가 의존성을 수동으로 관리할 필요를 줄여준다.
의존성주입을 통해 코드의 재사용성을 높일 수 있으며, 다양한 상황에서 유용하게 활용될 수 있다.

예제 1: 간단한 의존성주입

예제 1에서는 간단한 의존성주입의 사용법을 설명한다.
이 예제는 기본적인 의존성주입의 개념을 이해하는 데 도움을 준다.
의존성주입을 통해 함수의 동작을 변경하거나 확장할 수 있는 방법을 보여준다.
코드 예시를 통해 실제 구현 방법을 시각적으로 이해할 수 있다.

예제 2: DB 연결 사용

예제 2에서는 데이터베이스(DB) 연결을 위한 의존성주입을 다룬다.
DB 연결을 외부에서 주입받음으로써, 코드의 유연성을 높일 수 있다.
이 예제는 DB 연결을 관리하는 방법과 그 이점을 설명한다.
실제 코드 예시를 통해 DB 연결을 어떻게 설정하고 사용할 수 있는지를 보여준다.

예제 3: 재사용 가능한 파라미터

예제 3에서는 재사용 가능한 파라미터를 사용하는 방법을 설명한다.
이 예제는 의존성주입을 통해 코드의 중복을 줄이는 방법을 제시한다.
재사용 가능한 파라미터를 통해 여러 함수에서 동일한 설정을 쉽게 적용할 수 있다.
코드 예시를 통해 재사용 가능한 파라미터의 실제 사용 사례를 보여준다.

미들웨어 개요

미들웨어는 소프트웨어 애플리케이션 간의 상호작용을 지원하는 소프트웨어이다.
미들웨어의 중요성: 다양한 시스템과 애플리케이션 간의 통신을 원활하게 하여 데이터 처리 및 관리의 효율성을 높인다.

연산자 정의

연산자(Operator): 데이터 처리에 사용되는 기호 또는 키워드이다.
피연산자(Operand): 연산자의 입력값을 의미한다.
미들웨어의 역할: 연산자와 피연산자를 통해 데이터의 흐름을 관리하고 조작하는 기능을 수행한다.

연산자와 피연산자

연산자의 기능:
데이터 처리의 기본 단위로 작용한다.
다양한 형태의 연산을 수행할 수 있다.

피연산자의 중요성:
연산자가 작용하는 대상이 되며, 데이터의 의미를 결정짓는 요소이다.

FastAPI에서의 미들웨어

FastAPI: Python 기반의 웹 프레임워크로, 미들웨어를 쉽게 정의할 수 있는 기능을 제공한다.
미들웨어 정의 방법:
@app.middleware("http") 데코레이터를 사용하여 HTTP 미들웨어를 정의한다.
이 방법을 통해 요청과 응답을 가로채어 처리할 수 있다.

FastAPI 미들웨어 사용법

미들웨어의 정의:
FastAPI에서는 HTTP 요청을 처리하기 위해 미들웨어를 설정할 수 있다.
미들웨어는 요청을 가로채어 추가적인 처리를 수행할 수 있는 기능을 제공한다.

예시: 요청의 로깅, 인증, 데이터 변환 등의 작업을 미들웨어에서 수행할 수 있다.

CORS 개요

CORS 설정: Cross-Origin Resource Sharing의 약자로, 웹 애플리케이션이 다른 도메인에서 리소스를 요청할 수 있도록 허용하는 메커니즘이다.

CORS 정의

CORS란?: CORS는 웹 브라우저가 다른 도메인에서 리소스를 요청할 때 보안상의 이유로 발생하는 제약을 완화하는 방법이다.
연산자(Operator):
데이터 처리에 사용되는 기호 또는 키워드이다.
피연산자(Operand): 연산자의 입력값을 의미한다.

FastAPI에서 CORS 설정

FastAPI에서 CORS 설정 방법:
FastAPI 프레임워크를 사용하여 CORS를 설정하는 방법에 대한 설명이 포함되어 있다.
설정 방법은 두 가지로 나뉘어 있으며, 각각의 방법에 대한 구체적인 설명이 필요하다.

주요 설정 파라미터 설명

주요 설정 파라미터:CORS 설정 시 사용되는 주요 파라미터에 대한 설명이 포함되어 있다.
각 파라미터의 기능과 사용법에 대한 구체적인 정보가 제공된다.

머신러닝의 기본 개념

머신러닝이란 무엇인가?: 머신러닝은 컴퓨터가 명시적 프로그래밍 없이 데이터로부터 학습하는 인공지능의 한 분야이다.
핵심 요소:
데이터에서 패턴을 발견하고 예측 및 결정을 수행하는 것.
자동 개선: 데이터와 경험을 통해 성능을 자동으로 개선하는 것이 중요하다.

머신러닝의 중요성

자동화: 반복 작업과 대량 데이터 처리의 효율성을 높인다.
예측: 과거 데이터를 기반으로 미래의 추세를 예측할 수 있다.
개인화: 사용자 맞춤형 서비스를 제공하는 데 기여한다.
통찰력 발견: 데이터 속 숨겨진 패턴 및 관계를 발견하는 데 도움을 준다.

머신러닝의 종류

머신러닝의 유형:
지도 학습 (Supervised Learning):
레이블링된 데이터로 학습하여 새로운 입력에 대한 출력을 예측하는 것.
예: 분류, 회귀.
비지도 학습 (Unsupervised Learning):
레이블 없는 데이터에서 패턴이나 구조를 발견하는 것.
예: 군집화, 차원 축소.
강화 학습 (Reinforcement Learning):
환경과 상호작용하여 보상을 최대화하는 학습.
예: 게임 AI, 로봇 제어.

지도 학습 알고리즘 개요

지도 학습 알고리즘: 레이블(정답)이 있는 데이터로 학습하여 새로운 입력에 대한 정확한 출력을 예측하는 것을 목표로 한다.
주요 유형:
회귀 (Regression): 연속적인 숫자값을 예측하는 것 (예: 집 가격).
분류 (Classification): 미리 정의된 클래스를 예측하는 것 (예: 스팸/정상).

선형 회귀 알고리즘

선형 회귀 (Linear Regression): 독립 변수와 종속 변수 간의 선형 관계를 모델링하는 기법이다.
목표: 오차(ϵ)를 최소화하는 계수(β)를 찾는 것이다.
최적화 방법: 최소 제곱법 (Least Squares Method)을 사용한다.
수식:( y = β_0 + β_1x_1 + ... + β_nx_n + ϵ )

로지스틱 회귀 알고리즘

로지스틱 회귀 (Logistic Regression): 이진 분류를 위한 확률 모델이다.
특징: 입력의 선형 조합을 시그모이드 함수에 통과시켜 결과를 0과 1 사이의 확률로 변환한다.
용도: 스팸 분류, 질병 유무 예측 등에서 사용된다.
시그모이드 함수:

비지도 학습 알고리즘 개요

비지도 학습 알고리즘: 레이블 없는 데이터에서 패턴과 구조를 발견하는 것을 목표로 한다.
주요 유형:
군집화 (Clustering): 유사한 데이터 포인트를 그룹으로 묶는 것 (예: 고객 세분화).
원 축소 (Dimensionality Reduction): 고차원 데이터의 차원을 줄이는 것 (예: 이미지 압축).

K-평균 군집화 알고리즘

K-평균 군집화 (K-Means Clustering): 데이터를 K개의 클러스터로 분할하는 알고리즘이다.
알고리즘 단계:
K개의 중심점을 초기화한다.
각 데이터 포인트를 가장 가까운 중심점에 할당한다.
각 클러스터의 중심점을 업데이트한다 (평균 위치).
수렴할 때까지 2-3 단계를 반복한다.

주성분 분석(PCA) 알고리즘

주성분 분석 (PCA): 차원 축소 알고리즘으로, 고차원 데이터의 분산을 보존하며 저차원으로 투영하는 기법이다.
알고리즘 단계:
데이터 표준화.
공분산 행렬 계산.
고유값 및 고유벡터 계산.
고유값이 큰 순서대로 주성분 선택.
데이터를 선택된 주성분 공간에 투영한다.

모델 평가 지표

회귀 모델 평가 지표:
MSE: 예측 오차 제곱 평균 (작을수록 좋음).
MAE: 예측 오차 절대값 평균 (작을수록 좋음).
R-squared: 데이터 분산 설명력 (1에 가까울수록 좋음).

분류 모델 평가 지표:
정확도 (Accuracy): 전체 중 정답 비율.
정밀도 (Precision): 양성 예측 중 실제 양성 비율.
재현율 (Recall): 실제 양성 중 양성 예측 비율.
F1 점수: 정밀도와 재현율의 조화 평균.
AUC: ROC 곡선 아래 면적 (1에 가까울수록 좋음).

군집화 모델 평가 지표:
실루엣 계수: 응집도와 분리도 (-1~1, 1에 가까울수록 좋음).
머신러닝 모델 개발 과정

단계:
문제 정의: 해결할 문제 유형 결정 (회귀, 분류 등).
데이터 수집: 필요한 데이터 확보.
데이터 전처리: 결측치, 이상치 처리, 스케일링 등.
모델 선택: 문제/데이터에 적합한 모델 선택.
모델 학습: 학습 데이터로 모델 훈련.
모델 평가: 테스트 데이터로 성능 측정 및 개선.
모델 배포/활용: 실제 시스템에 적용하고 모니터링한다.

딥러닝의 정의

머신러닝의 한 분야로, 인공 신경망(Artificial Neural Network) 모델을 사용한다.
여러 층(layer)으로 구성된 신경망을 활용하여 데이터로부터 복잡하고 추상적인 패턴을 학습하는 것이 딥러닝의 핵심이다.

머신러닝과 딥러닝의 관계

딥러닝은 머신러닝의 하위 분야로, 머신러닝은 데이터 학습을 위한 일반 기술을 포함한다.
딥러닝은 심층 신경망을 활용한 머신러닝 방법으로, 더 복잡한 패턴을 학습할 수 있는 능력을 가진다.

전통 프로그래밍과 딥러닝 비교

딥러닝의 기본 개념

뉴런 (Neuron):
인공 신경망의 기본 처리 단위로, 인간 뇌의 신경 세포를 모방함.
작동 방식:
입력 신호에 **가중치(weight)**를 곱함.
모든 곱셈 결과와 **편향(bias)**을 더함 (선형 결합).
활성화 함수(activation function)를 통과시켜 최종 출력을 결정함.

순전파와 역전파 과정

순전파 (Forward Propagation):
입력층에서 출력층 방향으로 데이터가 흐름.
각 층의 뉴런이 계산을 수행 (선형 결합 + 활성화 함수).
최종 예측값을 계산하는 과정.

역전파 (Backpropagation):
출력층에서 입력층 방향으로 오차가 전파됨.
예측값과 실제값의 차이 (손실)를 기반으로 손실 함수에 대한 가중치/편향 기울기를 계산함.
연쇄 법칙을 활용하여 기울기를 계산함.

경사하강법과 손실 함수

경사하강법 (Gradient Descent):
최적화 알고리즘으로 손실 함수를 최소화하는 것을 목표로 함.
기울기의 반대 방향으로 가중치/편향을 업데이트함.
학습률(α)로 업데이트 폭을 조절함.

손실 함수 (Loss Function):
모델의 예측값과 실제값의 차이를 측정하는 지표.
모델 학습의 목표는 손실 함수 값을 최소화하는 것임.
문제 유형에 따라 다른 손실 함수를 사용함.

과적합과 방지 기법

과적합 (Overfitting):
학습 데이터에 과하게 맞춰져 새 데이터에 대한 성능이 저하됨.
모델이 복잡하고 데이터가 부족할 때 발생함.

과소적합 (Underfitting):
학습데이터조차 제대로 학습하지 못하는 경우.
모델이 단순하고 데이터가 부족하거나 질이 낮을 때 발생함.

과적합 방지 기법:
규제화 (Regularization): 모델의 복잡도를 제한 (L1, L2 규제).
데이터 증강 (Data Augmentation): 학습 데이터의 양을 늘림.
조기 종료 (Early Stopping): 검증 성능이 나빠지면 학습을 중단함.
드롭아웃 (Dropout): 신경망의 일부 뉴런을 임의로 비활성화함.

딥러닝 프레임워크 소개

딥러닝 프레임워크는 딥러닝 모델을 개발, 학습, 평가하는 도구로, 복잡한 모델을 쉽게 구축하고 GPU를 활용할 수 있도록 돕는다.
주요 프레임워크:
TensorFlow: 구글이 개발하였으며, 범용적이고 확장성이 우수함.
PyTorch: 페이스북이 개발하였으며, 연구 개발 분야에서 선호됨.

Keras

TensorFlow의 고수준 API로, 사용하기 쉬운 인터페이스를 제공함.

PyTorch의 특징

PyTorch:
Python 기반이며, 동적 신경망을 지원함.
직관적인 API와 활발한 커뮤니티를 가지고 있음.

실습 내용

1. 실습 목표

FastAPI의 라우터 분리, 의존성 주입, 인증, 파라미터 활용 등 실전 API 설계 및 구현 패턴을 연습합니다.
4.29/4.30/5.2 과제 코드를 라우터 분리 구조로 리팩토링합니다.
DB 연결 파트에 대한 의존성 주입(연결 종료 포함)을 실습합니다.

2. 주요 실습 내용

A. FastAPI 기본 기능 연습

DB 연결 의존성 주입
get_db() 함수에서 DB 연결 객체를 yield하고 finally에서 연결 종료 메시지 출력.
엔드포인트에서 Depends(get_db)로 의존성 주입.

쿼리 파라미터 및 Depends 활용
get_limit() 함수로 쿼리 파라미터 limit 기본값(3) 설정.
/slice 엔드포인트에서 limit만큼 데이터 슬라이싱 반환.

인증 토큰 체크
check_token() 함수에서 쿼리 파라미터 token이 "secret-token"이 아니면 401 에러 발생.
/secure 엔드포인트에서 인증 성공 메시지 반환.

B. 라우터 분리 실습

APIRouter 사용
예시로 users 라우터를 별도 파일에 분리.
인증 토큰 체크 후 사용자 정보 반환하는 /users/info 엔드포인트 구현.
main.py에서 app.include_router()로 라우터 등록.

C. 과제 리팩토링 및 확장

4.29, 4.30, 5.2 과제 코드를 라우터 분리 구조로 수정.
DB 연결 파트에 대해 의존성 주입(연결 종료 필수) 적용.
Swagger 문서에서 각 라우터별 API 확인.

D. 환경 및 패키지 설치

fastapi, uvicorn, pymongo 등 필수 패키지 설치 및 버전 확인.
Jupyter 환경에서 nest_asyncio로 비동기 서버 실행.

3. 주요 코드 패턴 예시

의존성 주입

def get_db():
    db = {"conn": "ok"}
    
    try:
        yield db
    finally:
        print("DB 연결 종료")

@app.get("/data")
def get_data(db = Depends(get_db)):
    return {"conn": db["conn"]}

쿼리 파라미터 + Depends

def get_limit(limit: Optional[int] = Query(3)):
    return limit

@app.get("/slice")
def get_slice(limit: int = Depends(get_limit)):
    data = ["a", "b", "c", "d", "e"]
    return data[:limit]

인증 토큰 체크

def check_token(token: str = Query(...)):
    if token != "secret-token":
        raise HTTPException(status_code=401, detail="Unauthorized")

@app.get("/secure")
def get_secure(token: str = Depends(check_token)):
    return {"message": "인증 성공"}

라우터 분리

# routers/users.py
router = APIRouter()

@router.get("/info")
def user_info(token: str = Depends(check_token)):
    return {"user": "Jay", "token": token}

# main.py
app.include_router(users.router, prefix="/users", tags=["Users"])

본격적으로 ML/DL 과정이 시작되기에 흥미도가 다시 커지고 있다. 정말 접해보지 않은 내용이기에 이해하는데 속도가 느리겠지만,,

중요한 부분이기도하고, 흥미도 있기때문에 최대한 선택과 집중을 해서 잘 따라가보도록 하려한다.

오늘 ML/DL강의는 맛보기(?)형식으로 가볍게 설명해주셨고, 따라서 실습 또한 오늘은 없었다. 그래서 이 시간에 이렇게 일지를 작성중이다ㅎ

본 후기는 [한글과컴퓨터x한국생산성본부x스나이퍼팩토리] 한컴 AI 아카데미 (B-log) 리뷰로 작성 되었습니다.