이번 글에서는 멀티 Agent와 2차 미니 프로젝트를 진행하며 느낀 점에 대해 이야기해보려고 한다. 4주차와 마찬가지로 Agent 관련 내용의 범위가 방대하다.. 그렇기에 이번에도 내용을 두 편으로 나누어 작성하려고 한다. 먼저 5주차-1에서는 Multi-Agent에 대해 다루고, 5주차-2 회고록에서는 미니 프로젝트 후기와 함께 프로젝트를 진행하며 배운 점/나아간 점들을 정리해보려 한다. 특히 이번 02 Mini Project에서는 강사님께서 다양한 실습 자료를 제공해주셨고, 01 Mini Project와 함께했던 팀원들을 떠나 새로운 팀원들과 함께 프로젝트를 진행하게 되었다. 새로운 팀원들과 협업하며 느꼈던 점, 함께 공부하고 고민했던 과정, 그리고 그 안에서 배우고 성장했던 경험들을 자세히 기록해보려고 한다. 먼저 Multi-Agent내용 복습을 해보자

1.상태(State) 설계

지난 4주차에서는 단일 에이전트(Single Agent)의 기초와 RAG를 통한 지식 확장을 학습했다. 하지만 현실의 문제는 단일 에이전트가 처리하기에는 너무 복잡하거나, 여러 단계의 전문적인 지식을 동시에 요구하는 경우가 많다. 이번 파트에서는 이러한 한계를 극복하기 위한 Multi-Agent 시스템의 필요성과, 상태(State) 설계에 대해 복습 진행!

1.1. Single Agent의 한계와 Multi-Agent의 등장

하나의 에이전트가 모든 일을 처리하는 방식은 마치 한 명의 박사님/교수님(?)이 기획, 디자인, 코딩, 테스트를 모두 혼자 하는 것과 같다. 초기에는 효율적일 수 있지만, 프로젝트가 커지면 다음과 같은 문제가 발생할 수 있다.

• 복잡도 증가: 에이전트에게 주어지는 프롬프트와 도구가 너무 많아지면 모델이 집중력을 잃고 엉뚱한 결과를 내놓을 확률이 높음
• 컨텍스트 윈도우의 압박: 대화가 길어질수록 모든 이력을 하나의 에이전트가 들고 있기에는 토큰 비용이 급증하고 핵심 정보를 놓치기 쉬움
• 전문성 부족: 특정 분야(예: 코드 분석 vs 데이터 시각화)에 특화된 프롬프트를 하나로 섞으면 성능이 저하

이러한 문제를 해결하기 위해 Multi-Agent 방식을 사용. 이는 각기 다른 역할(Role)과 전문 도구를 가진 여러 에이전트가 협업하여 복잡한 목표를 달성하는 구조다.

1.2. Multi-Agent의 핵심 이점

Multi-Agent 시스템으로 전환한다면?

• 관심사 분리 (Separation of Concerns): 각 에이전트는 자신에게 할당된 작은 문제에만 집중하므로 정확도가 상승
• 유연한 확장성: 새로운 기능이 필요할 때 전체 시스템을 수정하는 대신, 특정 역할을 수행하는 에이전트 하나/여러개를 추가하면 됨
• 디버깅 용이성: 문제가 발생했을 때 어떤 단계, 어떤 에이전트에서 오류가 났는지 추적하기 쉬움

1.3. 상태(State) 설계

Multi-Agent 시스템에서 가장 중요한 것은 "에이전트들이 정보를 어떻게 주고받는가?"이다. LangGraph에서는 이를 State(상태) 객체를 통해 해결

상태는 에이전트들 사이를 흐르는 '공유 메모리' 단순히 메시지 이력을 쌓는 것을 넘어, 시스템이 필요로 하는 특정 데이터(예: 분석 결과, 사용자 정보, 현재 단계 등)를 구조화하여 정의한다.

효과적인 State 설계 전략

1. 공통 스키마 정의: 모든 에이전트가 이해할 수 있는 메시지 리스트(Annotated[list, add_messages])를 기본으로 포함
2. 전용 필드 활용: 루프를 돌거나 특정 조건을 판단할 때 필요한 플래그 변수나, 중간 결과물을 저장할 필드를 추가
3. 독립성 유지: 각 에이전트는 전체 State 중 자신이 필요한 부분만 읽고, 작업이 끝나면 업데이트가 필요한 부분만 반환하여 상태를 갱신

참고/출처 https://www.hanbit.co.kr/channel/view.html?cmscode=CMS8333330411 https://cloud.google.com/discover/what-is-a-multi-agent-system?hl=ko https://wikidocs.net/331297

2. Router 패턴

2.1. Router 패턴이란?

사용자의 요청이나 현재 상태를 분석해서, 가장 적합한 에이전트에게 작업을 할당하는 아키텍처 패턴이다. (콜센터의 ARS 안내원 같은 역할)

2.2. Router 패턴의 작동 방식

단순히 질문에 바로 대답하는 것이 아니라, "이 질문은 어떤 전문가가 처리하는 게 제일 좋을까?"를 먼저 고민(분류)하는 것이 핵심이다.

• 의도 파악 (Intent Classification): Router 역할을 맡은 LLM이 사용자의 입력값을 읽고 핵심 의도를 분류함
• 분기 처리 (Routing): 분류된 결과(예: 코드 질문, 디자인 질문, 일반 질문)에 따라 특정 에이전트로 작업 흐름을 넘김
• 전문가 처리: 작업을 전달받은 전문 에이전트가 자신의 특화된 프롬프트와 도구(Tool)를 사용해 정확한 답변을 생성

2.3. LangGraph에서의 구현 포인트

LangGraph로 Router 패턴을 구현할 때 핵심은 조건부 엣지(Conditional Edge)다.

1. 라우터(Router) 함수/노드 생성: 현재 State(상태)를 읽어보고 조건에 따라 "Coder_Agent", "Reviewer_Agent" 등의 문자열(결과값)을 뱉어내는 판단 로직을 작성한다.
2. 분기점(Routing) 설정: add_conditional_edges를 사용해 라우터 노드의 판단 결과와 실제 이동할 다음 노드들을 매핑(Mapping)하여 연결해준다.

출처/참고 https://wikidocs.net/318951 https://wikidocs.net/322453 https://docs.aws.amazon.com/ko_kr/prescriptive-guidance/latest/agentic-ai-patterns/workflow-for-routing.html

3. Supervisor 패턴

3.1. Supervisor 패턴이란?

단어 뜻 그대로 중앙 통제자 역할을 하는 에이전트를 하나 두고, 이 관리자가 여러 에이전트들을 지휘하는 아키텍처다. 어떤 작업을 누가 먼저 할지, 그 다음엔 누구에게 넘길지, 작업이 충분히 완료되었는지(종료할지)를 중앙에서 지속적으로 판단하고 통제한다.

3.2. Router 패턴과의 결정적 차이점

- Router (접수처): "이 질문은 코드 관련이니까 Coder_Agent한테 가!" -> (한 번 분기하면 끝. 단방향)
- Supervisor (프로젝트 매니저): "Search_Agent야, 자료 먼저 찾아와. (결과 확인 후) Planner_Agent야, 찾은 자료 바탕으로 계획서 써봐. (결과 확인 후) 음, 완벽하군. 이제 FINISH!" -> (중앙에서 지속적인 피드백과 반복/루프 통제)

3.3. 작동 방식

강의에서 다룬 '여행 계획 에이전트'를 떠올려 보자. 사용자가 *"부산 2박 3일 가족 여행 코스 짜줘"*라고 요청했을 때 시스템은 다음과 같이 움직인다.

1. 지시: Supervisor가 요청을 분석하고, 먼저 명소 정보가 필요하다고 판단하여 Search_Agent(검색 담당)에게 지시를 내림.
2. 작업 및 보고: Search_Agent가 부산 명소 10곳을 찾아 State(공유 메모리)에 저장하고 Supervisor에게 보고.
3. 다음 지시: Supervisor가 검색된 내용을 확인한 뒤, 이번에는 Planner_Agent(일정 담당)에게 "이 장소들을 모아서 2박 3일 일정을 작성해"라고 지시.
4. 검토 및 종료: 일정이 완성되면 Supervisor가 최종 검토 후 FINISH 상태를 선언하고 사용자에게 결과물 제공.

3.4. LangGraph에서의 구현 포인트

Supervisor 패턴을 구현할 때의 핵심은 '관리자 전용 프롬프트'와 '상태(State)를 통한 대화 기록 공유'다.

1. 팀장(Supervisor) 프롬프트 세팅: "너는 여러 에이전트(Search, Planner 등)를 관리하는 매니저야. 현재 대화 내역(State)을 읽고, 다음으로 어떤 에이전트가 나서야 할지 텍스트로 내뱉어. 만약 사용자 요청이 모두 해결되었다면 'FINISH'를 출력해."라고 명확히 역할을 부여해야 한다.
2. 동적 라우팅 연결: Supervisor 노드의 결과값(다음 작업자 이름 or FINISH)에 따라 그래프의 흐름이 해당 에이전트 노드나 종료(End)로 향하도록 Conditional Edge를 촘촘하게 연결해 준다.

참고/출처 https://wikidocs.net/270690 https://ohyeah12.tistory.com/24 https://github.com/braincrew-lab/langgraph-v1-tutorial

4. Network 패턴

4.1. Network 패턴이란?

Network 패턴은 중앙에 관리자를 두지 않고, 각 에이전트들이 알아서 판단하여 다른 에이전트에게 주도권을 직접 넘겨주는 아키텍처다.

4.2. Network 패턴의 작동 방식

강의에서 다룬 고객센터(CS) 봇에 대해 작동방식을 생각해보자, 예시로 사용자가 *"앱 설치도 안 되고, 결제도 이상해요. 취소해 주세요!"*라고 복합적인 불만을 접수한다.

1. 초기 대응: Main Agent가 불만을 접수하고, 기술적인 문제라고 판단해 Tech_Agent(기술 지원)에게 바통(Handoff)을 넘김.
2. 기술 지원의 판단: Tech_Agent가 앱 설치 문제를 안내함. 그런데 텍스트를 읽어보니 '결제 취소' 요청도 있음. "결제 취소 권한은 나한테 없는데?"라고 스스로 판단.
3. 직접 토스(Handoff): Tech_Agent가 중앙 관리자를 거치지 않고, 알아서 Refund_Agent(환불 지원) 부서로 작업을 바로 넘김.
4. 마무리: Refund_Agent가 결제 취소 절차를 진행하고 사용자에게 답변 제공.

구현 포인트: 에이전트가 다른 에이전트를 호출할 수 있는 도구(Tool)를 가지게 만들어서, 특정 조건이 되면 마치 함수를 실행하듯 다른 에이전트를 호출하도록 프롬프트와 그래프를 구성하는 것이 핵심이다.

참고/출처 https://rudaks.tistory.com/entry/langgraph-Multi-agent-Network https://wikidocs.net/322453

생각정리

이번 추가 과제인 'AI 면접관 Agent 시스템' 실습을 진행하면서 "정말 재밌다, 앞으로 더 깊게 파보고 싶다"라는 생각이 강하게 들었던 시간이었다. 단순히 남의 코드를 따라 치지 않고 직접 아키텍처를 비교하고 상태(State)의 흐름을 파악하면서 개념을 명확하게 나의 것으로 만들었다는 점에서 의미가 크다. 이전까지 나에게 언어 모델은 그저 '질문하면 정답을 빨리 내주는 도구' 정도에 불과했다. 프롬프트를 얼마나 잘 작성하고 세세하냐에 따라 달라지는 결과물의 전부인 줄 알았다. 하지만 이번에 LangGraph를 활용해 Multi-Agent 시스템을 구축해보면서, 단순한 도구가 아님을 느끼게 된거 같다. 이력서에서 약점을 찾아내는 요원, 그 약점을 파고들어 날카로운 면접 질문을 던지는 요원, 그리고 지원자의 대답을 듣고 다시 꼬리질문을 할지 다음 주제로 넘어갈지 판단하는 요원까지. 내가 직접 정의한 규칙과 공유 메모리 위에서 여러 특화된 AI들이 데이터를 주고받는 방식이 재밌었다. 결국 앞으로의 AI 개발 생태계에서 가장 중요한 역량은 '어떤 모델의 API를 가져다 쓰느냐'가 아니라, "우리가 풀고자 하는 복잡한 문제를 어떻게 잘게 쪼개어 각 Agent에게 역할을 부여하고, 이들을 어떻게 효율적으로 협업시킬 것인가?"를 설계하는 사람이 성공하지 않을까..? 라는 생각이 든다. 이번 주차의 배움을 발판 삼아, 앞으로는 그저 만들어진 AI 도구를 소비하는 개발자가 아니라, 여러 AI Agent들을 이용해 나만의 강력한 자동화 파이프라인을 구축해내는 여러 경험을 쌓고 싶다. 다음에 하는 미니프로젝트 또는 내가 시간을 내서 토이프로젝트로 만들거나 과거에 만들었던 챗봇 시스템을 수정하면서 여러 경험들을 해보려고 한다. 5주차 공부를 마무리한다.

와... 너 정말, 핵심을 찔렀어.

이번 글에서는 지난 글에 이어, 현재 진행 중인 공모전과 코딩 테스트 스터디에 대해 이야기해보려고 한다. 처음 스터디를 시작할 때는 생각보다 모집이 활발해서 여러 선택지 사이에서 고민이 많았다. 코딩 테스트 스터디(자바/파이썬), 공모전 스터디, 교육 내용을 복습하는 스터디, 정기적으로 카페에서 모여 공부하는 오프라인 스터디 등 다양한 형태가 있었기 때문이다. 이 중에서도 나는 우리 반에서 모집 중인 스터디에 참여하면, 이후 미니 프로젝트나 본 프로젝트를 진행할 때 자연스럽게 팀을 구성하거나 협업하기에 더 좋지 않을까? 라는 생각이였다. 그래서 최종적으로 우리 반에서 진행하는 공모전 스터디와 자바 스터디에 참여하게 되었다.

공모전 스터디

공모전스터디 모임에는 총 8명이 함께하게되었는데 4/4로 쪼개 각 팀원들끼리 상의해 원하는 공모전에 참여하는 형식으로 진행하게 되었다. (팀장 회의는 매주 수요일 18:00~)

우리 조에서는 이번에 2026 AX 아이디어 경진대회에 참여하기로 했다. 생각보다 많은 시상을 이루기도 하며 주제가 다른 공모전에 비해 자유롭게 선정할 수 있다는 점이 컸다. 그리고 우리 팀원 (다애님, 현석님, 현준님) 모두가 개발을 한 경험이 있기 때문에 제품/서비스 에이전트 개발을 나가면 이번에 에이전트를 배우면서 좀 더 발전시킬 수 있다고 생각했었다.

그렇게 처음 시작을 했는데 경진대회 홈페이지를 찾아보니 개발제출물이 모두 앱으로 해야했네? .. (앱개발 경험은 모두가 많지 않았기에..)

이후 활용단계가 아닌 분석 단계로 방향을 바꾸어 지정 과제 분석부터 시작하게 되었다. 우리 스터디는 매주 적게는 2회, 많게는 4회까지 모이며 각자 맡은 파트와 공부한 내용을 공유하고 있다. 그렇게 우리가 이번에 시작하게된 공모전 주제는

데이터 지정 과제(한국수자원공사) - 조류경보 예측 AI 모델 개발!

총 12개의 지정 과제가 있었지만, 각자 관심있는 데이터나 주제를 맡아 조사하고 발표했다. 그중 다애님이 관심 있게 살펴보고 제안한 한국수자원공사의 과제를 선택해 진행하게 되었다. 대청댐, 유해조류, 활용해야 할 데이터 등 전반적인 도메인 지식이 부족한 상태였기 때문에, 각자 조사할 내용을 나누어 학습한 뒤 회의 시간에 화면 공유를 통해 발표하는 방식으로 진행하고 있다. (자연스럽게 토론도 이어지다 보니 매 회의가 1시간 20분을 훌쩍 넘기곤 하는데.. 정상 이겠죠?) 학교 외에서 다른 사람들과 프로젝트를 진행해본 경험이 많지 않아 처음에는 걱정도 있었지만, 다애님과 현준님은 1차 미니 프로젝트를 함께했던 팀원이라 오프라인에서 이미 안면을 익혀 조금(?) 친해진 상태였고, 현석님은 코딩 테스트 스터디를 함께하고 있어 이번 공모전을 계기로 더 많은 이야기를 나누며 가까워질 수 있을 것 같았다. 우리가 진행하는 방식은 비교적 체계적이다. 자료 공유와 간단한 회의록 작성, 일정 관리를 위해 노션을 활용하고 있으며, 주관기관에서 제시한 다양한 지정 과제를 기반으로 데이터 전처리와 모델 개발을 진행해야 하기 때문에 깃허브 저장소도 별도로 만들어 협업하고 있다. (간단한 질문, 궁금한 내용은 카톡 or Teams 활용!)

춘배 1

춘배 2

춘배 3

Github

인사말

열렬한 회의중 111

열렬한 회의중 222

이번 공모전을 시작으로 우리가 교육이 끝나는 9월전까지 많은 공모전을 도전하고 많이 함께 이것저것 만들어 볼 수 있을거 같다. 우리 팀원들에게 항상 감사드립니다.

다루는 내용이 궁금하다면? 노션 링크 깃허브 링크

코딩테스트 스터디

코딩 테스트를 준비하는 스터디 모임에서는 자바/파이썬 모집 글이 있었지만 나는 자바 스터디 모임을 진행했다. 우선 나에게 배경지식에 자바는 학교 전공수업에서 배우고 프로젝트를 간단하게 1개 사용해 본 적 이외에는 잘 사용하지 않았었다. 파이썬에 경우에는 백준/프로그래머스 사이트 등에서 코딩 테스트 문제를 대학교 때 간간히 풀어서 어느 정도 알고 있어 자바로 코테를 진행하면서 도전해 보려고 했다. (알고리즘, 문제풀이 구현 방식은 어느 정도 기억? 하고 있다고 생각해서 클래스와 객체를 활용한 문제 해결 방식을 풀면서 익혀보려고 했다)

Python - Baekjoon Online Judge

기본적으로 카톡방이 있지만 현재는 활발하게 자신의 코드를 공유하지는 않고 코딩마스터스를 이용해 일마다 10문제씩 풀고 구글docs를 이용해 각자 자신이 푼 코드와 상대방에 코드를 공유하는 방식이다. (따로 회의는 진행하지 않았다.) 그렇기에 개인이 집중해서 문제를 풀면서 역량을 늘리는것이기에 스터디모임에 역할이 없다고 생각하지만 문제는 하루에 하나씩은 풀자는 생각으로 문제를 풀고 있다. 파이팅해자고..

백준사이트 서비스 종료.... 믿기지 않습니다.. 아직 취업 못했는데..

생각정리

이번에는 따로 글로 정리하진 않았지만, 5/6반에서 모집한 기자단에 지원했고 운 좋게 선정되었다. 교육을 시작하면서부터, 나도 부트 캠프를 진행하게 된다면 배운 내용이나 그때의 생각들을 꾸준히 다시 블로그로 돌아와 남겨보자는 마음을 가지고 있었다. 이 과정이 끝난 이후에도 기록을 다시 꺼내보면서 나에게도 도움이 되고 내 글을 방문하게 된다면 방문 한 이에게도 도움이 되지 않을까 하는 생각이 들었고, 그 명분과 약간의 책임감으로 계속 써 내려간다면 쉬지 않고 앞으로 나아갈 수 있을 것 같았다. 예전에 대학교에서 만난 친해진 선배가 있었다. 폴더별로 txt 파일을 만들어 매일 기록을 남기던 분이었는데, 그때 이런 이야기를 해주셨다. “배운 내용은 결국 다 까먹는다. 천재가 아닌 이상 계속 다시 보게 된다. 시험 기간에도 보고, 그 이후에도 보게 된다. 그리고 교수님의 지식은 내 지식이 아니니까, 반드시 내 말로 정리해봐야 한다.” 그 말을 들으면서, 단순히 하루동안 배운 내용을 나의 머리에 꾸역 넣는것과 공부를 진행하면서 기록까지 꾸준히 남기는 건 또 다른 영역이라는 생각이 들었다. 그런데 막상 조금씩이라도 기록을 시작해보면, 그게 어느 순간 습관이 되고 결국 나를 성장시키는 시간이 되는 것 같다. 지금은 나도 후배들에게 비슷한 이야기를 해줄 수 있게 된 것 같다. 2024년부터 Velog, GitHub, Notion, Obsidian 등에 사소한 것까지 기록해왔다. 연구실, 전공에서 배운 내용, 진행했던 프로젝트/막혔던 부분과 왜 찾았는지/해결했는지, 프로젝트에서 맡았던 역할, 느낀 점, 서비스 프로젝트 이후 배포나 유지보수 과정에서 겪은 어려움, 그리고 학생회나 소모임, 대회활동 같은 일상적인 경험들까지. 그렇게 쌓인 1일, 1주일, 1달, 1년의 기록들이 필요할 때마다 다시 꺼내볼 수 있는 자료가 되었고, 단순한 검색보다 훨씬 오래 기억에 남는 공부가 되는 것 같다. 아직 나는 글을 재미있고 유익하게 잘 쓰는 편은 아니지만, 쓰다 보니 자연스럽게 다른 사람의 글도 더 찾아보게 되고, 남이 읽기 편한 글, 좋은 글을 쓰기 위한 자료나 책에도 관심이 생긴다. 이것도 하나의 취미라고 할 수 있을까, 4주차 회고록을 마무리한다.

나만의 루틴을 탄탄히 만들자, 미루지 말자.

이번 주차는 크게 4주차-1(교육 정리)과 4주차-2(스터디 모임 회고록)에 대해 작성해 보려고 한다. 4주차에서는 AI Agent와 워크플로우 설계 대해 학습을 진행했다. 내용이 광범위하고 다음 주차, 프로젝트를 진행하기 위해서는 크게 복습을 한번 진행하는 것이 중요하다고 생각했기 때문에 주차를 나눠서 글을 작성하려고 한다. 4주차-2에서는 따로 스터디를 진행 중인 공모전/코딩테스트 스터디 모임에 대해 좀 더 이야기를 나눠보려고 한다. 이제 Agent에 내용에 관해 정리해 보자

1. AI Agent와 워크플로우 설계

들어가기 전 AI Agent는

• 모델 정의 (LLM 선택 및 프롬프트 엔지니어링)
• 지식 기반 구축 (RAG 및 벡터 데이터베이스 설정)
• 도구 정의 (외부 API, 웹 검색, 코드 실행 등 Tool 연동)
• 워크플로우 설계 (Planning, Reasoning, Reflection 구조화)
• 실행 및 모니터링 (실시간 대응 및 데이터 관리) 위 AI Agent 구축 사이클을 기억하자

이번 과정에서는 생성형 AI를 단순히 호출하고 답변을 얻는 것을 넘어서, 언어 모델이 스스로 의사를 결정하고 도구를 사용하여 문제를 해결하는 AI Agent를 구축하는 방법을 배우게 되었다. 특히 LangChain과 LangGraph 프레임워크를 활용하여 복잡한 워크플로우를 설계하는 것이 주된 목표다.

1.1 LLM 활용 방식과 LangChain의 역할

대규모 언어 모델(LLM)을 우리의 데이터에 맞게 활용하는 방법은 크게 세 가지로 나눌 수 있다. 첫째는 모델을 그대로 사용하는 것이고, 둘째는 나의 데이터를 추가로 학습시키는 파인튜닝(Fine-Tuning), 그리고 셋째는 외부 지식을 검색하여 프롬프트에 포함시키는 RAG(Retrieval-Augmented Generation) 방식이다. 파인튜닝은 연산 자원과 훈련 시간, 과적합 등의 한계가 존재하기 때문에 최근에는 RAG 기반의 접근이 매우 중요해지고 있다.

이러한 LLM 기반 애플리케이션을 쉽게 개발하도록 돕는 프레임워크가 바로 LangChain이다. LangChain은 대규모 언어 모델을 활용하여 다양한 컴포넌트들을 체인(Chain)으로 연결해 복잡한 작업을 자동화하도록 돕는다. 주요 구성 요소로는 모델(LLM), 프롬프트, 인덱스(벡터 DB 등), 메모리, 체인, 그리고 에이전트와 도구가 있다.

1.2. 메시지 구성과 프롬프트 엔지니어링

LangChain에서 모델에 입력값을 전달할 때는 단순한 문자열이 아닌, 명확한 역할을 부여한 메시지 객체를 사용한다.

메시지의 종류

• SystemMessage: AI에게 지침이나 역할, 성격을 지정하는 메시지다.
• HumanMessage: 사용자의 질문이나 요청을 담는 메시지다.
• AIMessage: AI가 반환한 응답을 나타낸다.

메시지를 구성할 때는 튜플 방식과 객체 방식을 모두 사용할 수 있다.

이러한 메시지들을 구조화하여 다중 메시지 기반의 흐름을 만드는 것이 ChatPromptTemplate이다. 프롬프트를 설계할 때는 역할(Role), 맥락과 목적(Context & Goal), 답변 형식(Format)을 명확하게 명시하는 프롬프트 엔지니어링이 필수적이다.

1.3. 모델의 답변 무작위성 제어

LLM은 내부적으로 다음 단어가 등장할 확률을 계산하여 텍스트를 생성한다. 이 생성 과정의 다양성과 무작위성을 제어하기 위해 몇 가지 중요한 파라미터를 조절할 수 있다.

• Temperature: 확률 분포 자체를 조절한다. 0에 가까울수록 가장 확률이 높은 단어만 선택하여 일관되고 논리적인 답변을 생성하며, 1 이상으로 높아질수록 낮은 확률의 단어도 선택할 가능성이 생겨 창의적인 답변을 도출한다.
• Top_k: 확률이 가장 높은 상위 K개의 단어만 다음 단어의 후보로 제한하는 방식이다.
• Top_p: 단어들의 누적 확률이 p 이상이 되는 최소 집합을 후보로 삼는다. 예를 들어 0.9로 설정하면, 상위 확률 단어들을 더해 총합이 90%가 되는 순간까지만 후보군에 포함시킨다.

1.4. 파이프라인 구성과 출력 결과 구조화

LangChain의 진정한 강력함은 컴포넌트들을 연결하는 LCEL(LangChain Expression Language)에서 나온다. 파이프(|) 연산자를 사용하여 데이터가 흐르는 직관적인 파이프라인을 구축할 수 있다.

# LCEL을 이용한 체인 구성 예시
chain = prompt | llm | parser
response = chain.invoke({"user_input": "추천 도서 알려줘"})

여기서 마지막에 연결된 parser는 Output Parser(출력 파서)를 의미한다. LLM은 기본적으로 단순한 문자열 텍스트를 반환하지만, 실제 애플리케이션 개발에서는 리스트나 JSON과 같이 구조화된 데이터가 필요한 경우가 많다.

이때 PydanticOutputParser를 활용하면 매우 편리하다. 파이썬의 Pydantic 라이브러리를 통해 우리가 원하는 데이터 스키마(예: 책 제목, 저자, 출판년도)를 명확히 정의하고, 모델이 해당 구조에 맞게 응답하도록 프롬프트 지침을 주입할 수 있다. 또한 반환된 데이터의 타입이 맞는지 자동으로 검증까지 수행해주어 출력의 안정성을 크게 높여준다.

참고/출처 https://docs.langchain.com/ https://brunch.co.kr/@ywkim36/147 https://www.samsungsds.com/kr/insights/what-is-langchain.html https://aws.amazon.com/ko/what-is/langchain/ https://pangguinland.tistory.com/318

2.RAG 기반 파이프라인 구축

대규모 언어 모델(LLM)은 자신이 학습하지 않은 최신 정보나 내부 비공개 문서에 대해서는 알지 못하며, 잘못된 정보를 사실처럼 말하는 할루시네이션(Hallucination) 문제가 발생하기 쉽다. LLM의 한계를 극복하기 위해 외부 지식을 검색하여 답변의 근거로 활용하는 RAG(Retrieval-Augmented Generation) 기술과 그 파이프라인 구축 과정을 정리!

2.1. RAG 개념의 이해

RAG는 쉽게 말해 '검색(Retrieval)'과 '생성(Generation)'을 결합한 기술이다. 사용자가 질문을 던지면 LLM이 바로 답변을 생성하는 것이 아니라, 먼저 준비된 지식 데이터베이스(Vector DB)에서 질문과 관련된 문서(Context)를 검색하여 찾아낸다. 그런 다음 검색된 문서의 내용을 프롬프트에 포함시켜 LLM에게 전달하고, LLM은 주어진 문맥만을 바탕으로 정확한 답변을 생성하게 된다.

이러한 시스템을 구축하기 위해서는 문서를 컴퓨터가 이해하고 검색할 수 있는 형태로 변환하여 저장하는 Vector DB 구축 과정이 선행되어야 한다.

2.2. Vector DB 구축 절차

Vector DB를 만드는 과정은 크게 4가지 단계(Load -> Split -> Embed -> Store)로 이루어진다.

(1) 데이터 불러오기 (Load)

가장 먼저 할 일은 다양한 포맷의 파일로부터 텍스트를 추출하는 것이다. LangChain에서는 Loader라는 도구를 제공하며, 파일 형식에 따라 알맞은 로더를 사용한다. 일반적인 텍스트 파일은 TextLoader, PDF 파일은 PyMuPDFLoader, CSV 파일은 CSVLoader를 사용하여 문서를 읽어 들인다. 로드된 데이터는 텍스트 내용(page_content)과 메타데이터(metadata)를 포함하는 Document 객체 형태로 변환된다.

(2) 텍스트 분할 (Split)

문서를 로드했다고 해서 그대로 LLM에 던져줄 수는 없다. LLM이 한 번에 처리할 수 있는 입력 토큰 수에 제한이 있기 때문이다. 따라서 긴 문서를 의미 있는 작은 단위인 청크(Chunk)로 나누는 작업이 필요한데, 이를 텍스트 분할이라고 한다.

텍스트를 나눌 때는 단순히 글자 수로만 자르면 문맥이 끊어질 수 있으므로, 문단이나 문장 단위를 고려하고 청크 간에 내용이 일부 겹치도록 설정하는 것이 중요하다. LangChain의 CharacterTextSplitter를 사용하면 최대 글자 수(chunk_size)와 겹치는 글자 수(chunk_overlap)를 지정하여 문서를 분할할 수 있다. 적절한 청크 크기(보통 300~800자)와 오버랩을 설정하는 것이 RAG의 검색 품질을 좌우하는 핵심 요소 중 하나다.

(3) 텍스트 벡터화 (Embed)

분할된 텍스트 청크들은 텍스트 자체로는 수학적 검색이 불가능하므로, 이를 숫자로 이루어진 벡터(Vector)로 변환해야 한다. 이 과정을 임베딩(Embedding)이라고 하며, 텍스트의 의미적 정보를 다차원 공간의 좌표로 매핑하는 것이다. OpenAI의 text-embedding-3-small과 같은 모델을 주로 사용하며, 의미가 유사한 텍스트일수록 벡터 공간 상에서 서로 가까운 위치에 놓이게 된다.

(4) 벡터 저장소에 저장 (Store)

마지막으로 임베딩된 벡터 데이터들을 효율적으로 저장하고 검색할 수 있는 데이터베이스에 보관한다. 이를 Vector Store라고 부른다.

2.3. 유사도 검색 원리

Vector DB에 문서가 저장되었다면, 이제 사용자의 질문을 임베딩하여 DB에 저장된 문서 벡터들과 비교할 수 있다. 이때 주로 사용되는 수학적 기준이 코사인 유사도(Cosine Similarity)다.

코사인 유사도는 두 벡터가 이루는 각도를 계산하여 텍스트 간의 의미적 유사성을 측정한다. 값이 1에 가까울수록 문맥적 의미가 매우 유사함을 뜻하며, 0이면 관계가 없고, -1이면 반대 의미를 가짐을 나타낸다. 시스템은 질문 벡터와 코사인 유사도가 가장 높은 상위 K개의 문서를 추출하여 응답의 근거로 사용한다.

2.4. RAG 파이프라인(Chain) 구성

지식 DB 준비가 끝났다면, 사용자의 질문을 받아 검색하고 답변을 생성하는 전체 파이프라인을 LCEL 문법으로 엮어주어야 한다.

1단계: Retriever 선언 Vector DB를 검색기(Retriever)로 변환한다. .as_retriever() 함수를 사용하며, 코사인 유사도를 기준으로 상위 몇 개(k)의 문서를 가져올지 설정한다.

2단계: RAG 전용 프롬프트 정의 LLM이 외부 지식을 활용해 답변하도록 역할을 고정하고, 제공된 문맥(Context) 내에서만 답하도록 프롬프트를 설계한다. 특히 "제공된 문맥에 답이 없다면 모른다고 답변하고 억지로 지어내지 마라"는 조건을 명시하여 할루시네이션을 방지한다.

3단계: LCEL 체인 연결 입력된 질문이 Retriever를 통과해 관련 문서(Context)를 찾아오고, 이 문맥과 원본 질문이 프롬프트 템플릿에 삽입된 후 LLM을 거쳐 최종 답변이 나오는 체인을 구성한다.

# 문서 객체 리스트를 하나의 문자열로 결합하는 포맷 함수
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# LCEL 기반 RAG 파이프라인 구성
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
)

# 챗봇 실행
response = rag_chain.invoke("가장 심각한 사이버 보안 위험이 뭐야?")

2.5. RAG 성능 최적화 고려 사항

RAG 파이프라인이 제대로 동작하더라도 검색 품질이나 생성 결과가 아쉬울 수 있다. 이를 개선하기 위해 다음과 같은 요소들을 튜닝해야 한다.

• 청크 전략: 문서의 특성에 맞춰 chunk_size와 chunk_overlap을 조정한다. 청크가 너무 작으면 문맥이 잘리고, 너무 크면 여러 주제가 섞여 유사도 검색 성능이 떨어진다.

• 검색 개수(k): LLM의 입력 토큰 한계를 넘지 않는 선에서 충분한 문맥을 제공하기 위해 최적의 k값을 찾는다 (보통 3~5개).

• 프롬프트 고도화: 출력의 제약(길이, 형식 등)을 프롬프트에 구체적으로 명시할수록 응답의 일관성이 향상된다.

참고/출처 https://m.blog.naver.com/rainbow-brain/224072340830 https://kr.linkedin.com/pulse/unlocking-power-rag-pipelines-enhancing-ai-real-time-data-zaveri--lmzif?tl=ko https://m.blog.naver.com/rainbow-brain/224040868079

3. AI Agent - LangGraph

모델이 단순히 주어진 질문에 대답하는 것을 넘어서, 주어진 목표를 달성하기 위해 스스로 계획을 세우고 도구를 활용하며 문제를 해결하도록 만들 수는 없을까? 능동적인 문제 해결 시스템인 AI Agent의 개념과, 이 에이전트의 복잡한 작업 흐름을 통제하기 위한 LangGraph의 정리!

3.1. AI Agent란 무엇인가?

AI Agent는 스스로 의사를 결정하며, 도구를 사용하여 목표를 달성하는 시스템이다. 단순한 텍스트 생성을 넘어, 다단계 추론과 외부 도구 호출 능력을 결합한 것이 특징이다. 즉, 언어 모델(LLM)에 손과 발, 그리고 기억력을 달아주어 하나의 독립적인 작업자로 만드는 과정이라고 이해할 수 있다.

AI Agent는 크게 네 가지 핵심 요소로 구성된다.

• 첫째, 시스템이 최종적으로 해결해야 할 목표(Goal)다.
• 둘째, 이 목표를 달성하기 위해 계획을 세우고 판단을 내리는 두뇌 역할의 추론 엔진(Reasoning Engine)이며 주로 GPT 같은 LLM이 담당한다.
• 셋째, 웹 검색, 계산기, 사내 API 등 에이전트가 호출하여 사용할 수 있는 외부 기능인 도구(Toolset)다.
• 넷째, 이전의 대화나 수집한 정보, 현재의 진행 상황을 저장하고 추적하는 공간인 메모리와 상태(Memory/State)다.

3.2. 워크플로우 제어를 위한 LangGraph

이러한 Agent 시스템을 구축하기 위한 프레임워크로는 여러 가지가 있지만, 복잡한 다단계 프로세스를 개발자가 원하는 대로 세밀하게 제어하기 위해 LangGraph를 활용한다. LangGraph는 에이전트의 작업 흐름을 그래프(Graph) 구조로 설계할 수 있게 해준다.

LangGraph를 구성하는 핵심 요소는 다음과 같다.

• State (상태): 그래프 전체를 관통하며 현재 상태 값을 저장하고 전달하는 역할을 한다. 에이전트가 통과하는 각 단계마다 정보가 누적되며, 파이썬의 TypedDict를 사용하여 어떤 데이터가 들어갈지 딕셔너리 형태로 명확히 구조를 정의한다.
• Node (노드): 특정 작업이나 판단을 수행하는 실제 단위다. 파이썬 함수로 구현되며, 상태(State)를 입력으로 받아 특정 작업을 수행한 후 업데이트된 상태를 반환한다.
• Edge (엣지): 노드와 노드를 연결하는 선으로, 작업의 흐름을 정의한다. 한 노드의 작업이 완료된 후 다음으로 이동할 노드를 지정한다.
• Conditional Edge (조건부 엣지): 단순한 순차적 이동이 아니라, 특정 조건이나 상태 값에 따라 노드 간의 분기 처리를 수행할 때 사용한다.

3.3. 에이전트 워크플로우의 세 가지 기본 패턴

상태와 노드, 엣지를 조합하면 다양한 형태의 워크플로우를 설계할 수 있다. (세 가지 그래프 구조를 학습)

(1) 단순 그래프 (Simple Graph)

입력, 처리, 출력으로 이어지는 단순한 파이프라인 형태다. 가장 기본적인 구조로, 시작점(START)에서 출발해 정의된 노드들을 차례대로 거친 후 종료점(END)에 도달한다.

(2) 라우팅 (Routing)

사용자의 입력이나 특정 조건에 따라 서로 다른 경로를 선택하여 실행 흐름을 제어하는 구조다. 이때 조건부 엣지(Conditional Edge)가 핵심적인 역할을 한다.

강의에서는 입력된 숫자가 짝수인지 홀수인지 판별하여 각각 다른 노드를 실행하는 예제를 다루었다. 짝수/홀수 판별 함수를 먼저 만들고, 이를 조건부 엣지에 연결하여 흐름을 동적으로 분기시키는 방식이다.

# 조건 분기를 결정하는 라우터 함수
def parity_condition(state: State):
    return "even" if state["number"] % 2 == 0 else "odd"

# 조건부 엣지 추가 (check_parity 노드 실행 후 분기)
builder.add_conditional_edges(
    "check_parity", 
    parity_condition,
    {"even": "even_node", "odd": "odd_node"}
)

(3) 반추 (Reflection)

에이전트가 스스로의 추론 과정이나 결과물을 돌아보고 피드백을 생성하여, 결과가 만족스러울 때까지 반복 작업을 수행하는 메커니즘이다. 그래프 상에서 특정 노드에서 종료로 가지 않고 다시 이전 노드로 돌아가는 루프(Loop)를 형성하여 구현한다.

예를 들어, 문서를 요약하는 노드를 거친 후 결과의 만족도를 평가한다. 평가 결과가 '만족'이면 시스템을 종료하지만, '불만족'이면 다시 생각해보기(반추) 노드를 거쳐 원래의 요약 노드로 되돌아간다. 이러한 순환 구조를 통해 에이전트는 한 번에 완벽한 답을 내지 못하더라도, 점진적으로 결과물의 품질을 향상시킬 수 있다.

참고/출처 https://wikidocs.net/268610 https://cobusgreyling.medium.com/whats-your-definition-of-an-ai-agent-edb7d5e1c760 https://www.langchain.com/langgraph

4. AI Agent와 Tool 활용

도구(Tool) 활용법과, 과거의 대화를 기억하며 도구를 능동적으로 사용하는 실질적인 챗봇 에이전트 구축 과정을 정리!

4.1. AI Agent와 Tool의 역할

일반적인 대규모 언어 모델은 사용자의 입력을 받아 단순히 텍스트 응답을 생성한다. 하지만 실제 업무에서는 실시간 웹 검색이 필요하거나, 정확한 수학 계산을 해야 하거나, 사내 데이터베이스를 조회해야 하는 등 외부 시스템과의 상호작용이 필수적이다.

이러한 외부 기능들을 에이전트가 사용할 수 있도록 묶어놓은 것을 Tool(도구)이라고 부른다. 모델은 사용자의 질문을 분석한 뒤, 스스로 판단하여 필요한 시점에 적절한 도구를 호출(Tool Call)하고 그 결과를 바탕으로 최종 응답을 만들어낸다.

도구는 크게 두 가지로 나뉜다.

• Custom Tool: 우리가 필요에 따라 파이썬 함수로 직접 정의하고 만든 도구다.
• 외부 도구: 검색 엔진(Tavily 등), 날씨 API 등 외부 업체에서 미리 만들어 제공하는 도구다.

4.2. 메모리를 가진 대화형 챗봇 만들기 (State 관리)

도구를 사용하는 복잡한 에이전트를 만들기 전, 먼저 에이전트가 과거의 대화를 기억하게 만들어야 한다. LangGraph에서는 이를 State를 통해 관리한다.

단순히 텍스트 하나만 주고받는 것이 아니라, 대화 기록 전체를 리스트 형태로 State에 담아 관리해야 문맥이 유지된다. 이때 매번 기존 리스트를 덮어쓰는 것이 아니라 새로운 메시지를 계속 누적해서 추가(Append)해야 하는데, LangGraph는 이를 아주 쉽게 구현할 수 있도록 add_messages라는 기능을 제공한다.

from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph.message import add_messages

# 대화 이력을 자동으로 누적해서 관리하는 State 구조
class State(TypedDict):
    messages: Annotated[list, add_messages]

이렇게 Annotated와 add_messages를 활용해 State를 정의하면, 새로운 메시지가 반환될 때마다 프레임워크가 알아서 기존 메시지 목록의 맨 뒤에 새 메시지를 추가해 준다. 이를 통해 모델은 항상 전체 대화 히스토리를 보며 자연스러운 맥락을 이어갈 수 있다.

4.3. Custom Tool 만들기 및 모델에 연결하기

에이전트에게 쥐어줄 도구를 만드는 방법은 매우 간단하다. 일반적인 파이썬 함수를 작성한 뒤, 그 위에 @tool 데코레이터만 붙여주면 LangChain이 인식할 수 있는 도구로 변환된다. 이때 함수 내부의 매개변수 타입과 독스트링을 명확히 적어주는 것이 중요한데, 모델이 이 설명을 읽고 언제 어떻게 이 도구를 써야 할지 결정하기 때문이다.

from langchain_core.tools import tool

# 계산기 도구 정의
@tool
def calculator_tool(expression: str) -> str:
    """수학 수식을 입력받아 계산 결과를 반환합니다."""
    return str(eval(expression))

# 1. 사용할 도구들을 리스트로 묶기
tools = [calculator_tool]

# 2. LLM에 도구 목록 연결 (Binding)
llm_with_tools = llm.bind_tools(tools)

가장 핵심적인 부분은 만든 도구들을 리스트로 묶어 LLM에 바인딩하는 것이다. 이 과정을 거쳐야만 LLM이 자신에게 어떤 무기들이 주어졌는지 인지하고, 필요할 때 함수 실행을 요청할 수 있다.

4.4. Tool을 사용하는 Agent 워크플로우 구성

이제 모델과 도구를 LangGraph의 노드와 엣지로 엮어 실제 에이전트의 워크플로우를 구성할 차례다. 도구를 사용하는 에이전트의 흐름은 대체로 다음과 같은 순환 구조를 가진다.

사용자 입력: 사용자가 질문을 던진다.

모델 판단 (call_model 노드): LLM이 질문을 분석한다. 만약 도구 사용이 필요 없다면 바로 최종 답변을 생성하고 종료(END)한다.

도구 호출 요청: 도구가 필요하다고 판단되면, LLM은 응답 텍스트 대신 "이 도구를 이런 매개변수로 실행해줘"라는 Tool Call 명령을 내뱉는다.

조건부 분기: 조건부 엣지가 모델의 응답을 확인하여 Tool Call이 포함되어 있다면 흐름을 도구 실행 노드로 보낸다.

도구 실행 (tools 노드): ToolNode가 실제 파이썬 함수를 실행하고 그 결과값을 State의 messages에 추가한다.

결과 피드백: 흐름은 다시 모델 판단 노드(call_model)로 돌아간다. LLM은 방금 실행된 도구의 결과값을 확인하고, 이를 바탕으로 최종 답변을 정리하여 사용자에게 전달한다.

이러한 과정을 통해 에이전트는 한 번에 답을 내기 어려운 복잡한 문제도 스스로 도구를 여러 번 호출해가며 해결책을 찾기

생각정리

Agent에 대한 공부는 처음이 아니었지만, 이번에는 이전보다 훨씬 깊이 있게 개념을 탐색하고 정리할 수 있었던 시간이었다. 단순히 겉핥기식으로 이해하는 것이 아니라, 직접 검색하고 구조를 파악하면서 개념을 보다 명확하게 이해할 수 있었다는 점에서 의미가 크다. 과거에는 Agent를 학습할 때 GitHub에서 스타가 많은 레포지토리를 중심으로 글을 읽고, 코드를 클론하여 실행해보는 방식에 집중했었다. 또한 실제 프로젝트에 Agent가 필요한지, 필요하다면 어떻게 적용할 수 있을지에 대한 고민보다는 구현 자체에 초점을 맞췄던 것 같다. 일종의 ‘바이브 코딩’에 가까운 접근이었다. 하지만 이번 학습을 통해 Agent의 전체적인 구조와 동작 방식, 그리고 실제로 어떻게 활용해야 하는지에 대해 한 단계 더 깊이 이해할 수 있었다. 단순히 사용하는 것을 넘어서, 어떤 상황에서 적절하게 적용할 수 있는지를 고민하게 되었다는 점이 가장 큰 변화다. 최근에는 다양한 Agent들이 등장하고 있고, 나 역시 GitHub Copilot, Cursor, Codex, Claw-Code 등 여러 도구의 도움을 많이 받고 있다. 이러한 흐름 속에서 Agent를 단순한 도구로 사용하는 것을 넘어, 나에게 가장 잘 맞는 형태로 어떻게 활용할 수 있을지 고민하는 것이 중요하다고 느꼈다. 이번 학습은 단순한 개념 이해를 넘어서, 앞으로 내가 진행할 프로젝트에 Agent를 왜 필요할지, 어떻게 활용하면 좋을지, 왜 화두가 되고 모두가 편리하게 사용하는지에 관한 생각을 하게했던거 같다. 4주차 공부를 마무리한다.

결국 차이를 만드는 것은 도구가 아니라, 그것을 바라보는 관점이다

Github-Private

이번주차는 크게 처음으로 미니프로젝트조가 생겨 조원들7명과 함께 미니프로젝트 및 아이데이션을 준비하게 되었다. 에이블 스쿨에서는 오프라인으로 에이블러들과 프로젝트를 진행 할 수 있게 강의실을 예약해서 이용할 수 있는데 수도권인 경우 KT 전농지점과 KT 판교빌딩 2곳이 있다. 나는 집에서 가기편한곳인 전농교육장을 예약해 방문했다.

01-MiniProject

전농교육장

나포함 조원 6명이 전농교육장에 방문해 함께 프로젝트를 진행했다.. 다른 사진을 하나도 안찍었네.. 우리가 한 프로젝트를 간단하게 봐보자

데이터 분포도 일부 확인

모델 학습

처음은 개인이 지정된 csv를 불러와 데이터 분석/전처리부터 시작해 직접 모델을 만들고 평가로 진행했다. 그 후 조원들과 개인이 작성한 코드에 대한 리뷰를 진행하는 시간이 충분히 주어져 조원들과 모델에 loss 값을 낮추기 위해 어떤 점을 보완하고 추가했으면 좋겠다는 의견을 많이 나눠서 좋았다. (랜덤이지만 처음 미니 프로젝트 조원들을 너무 잘 만난 거 같다) 우리조에서 나온 리뷰를 나열하자면

• 과적합에 대한 문제점이 무엇일까
• Class에 가중치를 둬 학습해보기
• EarlyStopping/ModelCheckpoint를 활용
• Dense를 깊게/얇게 조정하면서 시도하기
• Dropout/Learning rate/Batch_size등 값 조절하기
• 새로운데이터와 기존데이터에 새롭게(기존 모델구조와 같게)모델 학습 vs 새로운데이터와 기존모델을 불러와 재학습에 대한 리뷰
• code를 쓰면서 왜 사용하고 어떻게 표현해야하는지

들을 진행하고 하나의 코드로 통일해 미션을 끝냈다. (1번째 미니프로젝트가 끝나고 퇴근시간인 2호선, 1호선을 타고 집으로 가면서 죽을뻔했네)

아이데이션

아이데이션이라는 단어를 들어봤는데 이게 머였지..? 검색해 보자

아이데이션(Ideation)은 광고, 기획, 디자인 분야에서 새로운 아이디어를 생성(Generating), 발전(Developing), 커뮤니케이션(Communicating)하는 전 과정을 뜻하는 핵심적인 창의적 프로세스

01-미니 프로젝트를 진행한 조원들과 함께 진행하게 되었다. 정부가 운영하고 있는 나라장터나 최근 이슈가 되는 기업, 정부 관련된 뉴스를 조사해 각자 아이디어를 내고 토론하는 자리였다. 조원들과 토론하면서 각자 자신이 정한 아이디어에 대해 "이 서비스를 만들어야 하는 이유", "서비스를 기업/정부에 제시한다면 설득력이 있을까?"를 고민하게 하고 요구사항을 맞춰야 한다고 생각했다. 그렇게 작성을 진행했었는데 감사하게도 내가 조사한 과제명이 뽑혀 내 아이디어를 가지고 어떻게 더 발전할 수 있을지에 대해 토론하고 결과물을 내는 시간이었다. (결과물을 제출하기 전에 피드백을 받고 수정할 수 있는 시간이 있어서 좀 더 퀄리티 있는 결과물을 제출할 수 있었던 거 같다.)

생각정리

에이블 스쿨에 입교해 처음으로 팀원들이 생긴 귀중한 시간이었던 거 같고 개인/팀원으로써 코드/리뷰 와 서비스 개발에 필요한 아이디어(?) 마음가짐 등을 배울 수 있었던 자리여서 좋은 시간이었던 거 같다. 아쉬운점이라면 원하던 결과물을 만들기에는 시간이 조금 부족했던 점과 팀원들과 많이 소통을 못 해본 것이 아쉽다. 누구나 그렇다고 생각하지만 처음 대면한 사람을 만나고 대화를 한다는 것은 쉽지 않은 거 같다. 우리반에서는 OT-자기소개 시간에 MBTI를 말하는 시간이 있었는데 내 기억상 90% 이상이 I인 것으로 기억한다. (컴퓨터 만지는 사람이 보통 그런가..?) 그래도 오랜만에 팀프로젝트를 진행하며 좋은 감점을 느꼇다. 활동을 하면서 대학교에서 과대표나 멘토 멘티를 하면서 느꼈던 "상대방이 모르는 부분에 대해 알려주고 이해한 상대방이 만족을 느꼈을 때에 대한 행복"울 느꼈던 거 같다. 이 감정을 느끼는 방식은 남들과 조금 다를 수 있지만, 나에게는 지금까지 꾸준히 공부할 수 있게 만든 원동력 중 하나이며, 팀원에게 한마디 더 건넬 수 있는 자신감의 근원이기도 하다. (먼저 다가가야 상대방도 마음을 열것이다..!) 프로젝트를 짧게 진행해 이번 조원들과의 만남이 아쉽지만 다른 프로젝트와 활동을 하면서 같이 성장하고 싶은 마음이 드는 하루라고 생각하며 3주 차를 마무리한다.

내일은 없다.

Github-Private

ML에 대해 2일 동안 DL에 대해 1일 학습을 진행했다. 기간이 짧은 기간 동안 중요한내용을 빠르게 학습하고 바로 실습(코드)으로 진행해 개인이 문제를 해결하기보다 라이브러리 및 함수에 대해 익숙해지고 학습한 모델이 어떤구조와 어떤 흐름으로 이어가는지에 대한 전체적인 이해를 배운 거 같다. 정리해보자

1. 머신러닝 (Machine Learning)

들어가기전 머신러닝은

• 문제 정의
• 데이터 준비(데이터 전처리)
• 모델링(알고리즘 적용)
• 평가
• 성능 최적화(튜닝) 위 사이클을 꼭 기억하기

1-1. 데이터 전처리

알고리즘에 데이터를 넣기 전, 모델이 데이터를 잘 이해할 수 있도록 가공하는 필수 단계

• 결측치 처리: 비어있는 데이터(NaN)를 평균, 중앙값 등으로 채우거나 행 자체를 삭제한다.
• 가변수화 (One-Hot Encoding): 머신러닝 모델은 문자를 이해하지 못하므로, 범주형 데이터(예: 성별, 혈액형)를 0과 1로 이루어진 변수로 변환해 주어야 한다.
• 스케일링 (Scaling): 변수마다 값의 범위가 다르면(예: 나이는 1080, 연봉은 300010000) 단위가 큰 변수에 모델이 가중치를 과도하게 둘 수 있다. 따라서 모든 변수의 범위를 0~1 사이로 맞추는 정규화(MinMaxScaler)나 평균 0, 표준편차 1로 맞추는 표준화(StandardScaler)를 진행한다. 거리 기반 알고리즘(KNN 등)에서는 필수적이다.

1-2. 문제의 정의와 주요 알고리즘: 회귀(Regression) vs 분류(Classification)

목표 변수(Target)의 형태에 따라 접근 방식과 알고리즘을 선택하자!

출처/참고 : https://www.geeksforgeeks.org/machine-learning/ml-classification-vs-regression/

[회귀 모델링 (Regression)]

• 목표(Target): 연속적인 '숫자'를 예측하는 문제 (예: 집값 예측, 주가 예측, 매출액 예측). 실제 값과 예측값의 '오차(Error)'를 최소화하는 것이 핵심이다.
• 선형 회귀 (Linear Regression): 데이터의 경향성을 가장 잘 설명하는 하나의 최적의 직선(y = wx + b)을 긋는 방식. 빠르고 해석이 쉽지만 복잡한 패턴을 잡기는 어렵다.
• K-최근접 이웃 회귀 (KNN Regressor): 예측하려는 데이터와 가장 가까운 K개의 이웃 데이터를 찾아, 그 이웃들의 타겟 값 평균을 계산하여 예측한다.

[분류 모델링 (Classification)]

• 목표(Target): 데이터가 속할 '범주(Class)'를 예측하는 문제 (예: 스팸 메일 여부, 질병 유무). 정확하게 경계선을 그어 범주를 나누는 것이 핵심이다.
• 로지스틱 회귀 (Logistic Regression): 이름은 회귀이지만 분류에 사용된다. 시그모이드 함수를 통해 특정 클래스에 속할 확률(0~1)을 계산하여 0.5를 기준으로 분류한다.
• 의사결정나무 (Decision Tree): 스무고개처럼 조건(예: 나이가 30 이상인가? Yes/No)을 분기하여 데이터를 분류한다. 사람이 직관적으로 이해하기 좋고 설명력이 뛰어나다.
• 랜덤 포레스트 (Random Forest): 수많은 의사결정나무를 만들고, 각 나무의 예측 결과를 취합(투표)하여 최종 결과를 내는 앙상블(Ensemble) 기법이다. 단일 모델보다 성능이 훨씬 뛰어나며 과적합을 방지하는 효과가 있다.

1-3. 모델 성능 평가 (Evaluation)

학습된 모델이 처음 보는 데이터(Test Data)에 대해 얼마나 잘 작동하는지 객관적으로 평가

분류 모델 평가 지표 (Classification Metrics)

출처/참고 : https://glassboxmedicine.com/2019/02/17/measuring-performance-the-confusion-matrix/

[분류 평가지표와 오차행렬(Confusion Matrix)] 분류 문제는 오차행렬(TP, TN, FP, FN)을 기반으로 평가한다.

• Accuracy (정확도): 전체 예측 중 맞춘 비율. 데이터 불균형(예: 정상 99개, 불량 1개) 시 무조건 정상이라고만 찍어도 99%가 나오므로 신뢰하기 어렵다.
• Precision (정밀도): 모델이 'Positive'라고 예측한 것 중 실제 'Positive'인 비율. (예: 스팸으로 걸러낸 메일 중 진짜 스팸인 비율. 일반 메일을 스팸으로 걸러버리면 안 될 때 중요).
• Recall (재현율): 실제 'Positive'인 것 중 모델이 'Positive'로 찾아낸 비율. (예: 실제 암 환자 중 모델이 암이라고 예측한 비율. 병원 진단 모델처럼 실제 환자를 놓치면 안 될 때 가장 중요).
• F1-Score: 정밀도와 재현율의 조화 평균으로, 데이터가 불균형할 때 모델의 성능을 가장 객관적으로 대변한다.

1-4. 교차 검증(Cross Validation)과 모델 성능 튜닝(Hyperparameter Tuning)

개발자가 알고리즘에 직접 설정해 주어야 하는 '하이퍼파라미터'에 따라 성능이 극명하게 달라지므로, 이를 최적화하는 과정이 필요하다.

• K-Fold 교차 검증: 훈련 데이터를 통째로 한 번만 학습하는 것이 아니라, 데이터를 K개의 폴드(조각)로 나누어 K번 반복 학습 및 평가를 진행한다. 특정 데이터 셋에만 맞춰지는 것을 방지하고 모델의 평균적인 성능을 신뢰성 있게 평가할 수 있다.

• Grid Search (그리드 서치): 지정한 파라미터 값들의 '모든 경우의 수'를 다 조합해서 학습해 보고 가장 최고 성능(best_score_)을 내는 조합(best_params_)을 찾는 방법. 탐색 공간이 넓어지면 시간이 늘어난다.
• Random Search (랜덤 서치): 파라미터의 범위만 지정해 주고, 그 안에서 랜덤하게 조합을 뽑아 지정된 횟수(n_iter)만큼만 테스트하는 방법. 그리드 서치보다 시간은 훨씬 절약되면서도 꽤 괜찮은 최적의 값을 빠르게 찾아낸다.

출처/참고 https://ethen8181.github.io/machine-learning/model_selection/model_selection.html https://datarian.io/blog/grid-search-random-search https://blog.naver.com/hsj2864/222215638480 https://scikit-learn.org/stable/modules/cross_validation.html https://www.ibm.com/think/topics/fine-tuning

2. 딥러닝 (Deep Learning)

들어가기 전 딥러닝은

• 데이터 준비 (데이터 전처리 및 스케일링 필수)
• 구조 설계 (레이어, 노드, 활성화 함수 구성)
• 모델 컴파일 (손실 함수 및 옵티마이저 설정)
• 모델 학습 (Epoch 반복을 통한 가중치 업데이트)
• 성능 최적화 (Early Stopping, Dropout 등으로 과적합 방지)
• 평가 위 딥러닝 고유의 모델링 사이클을 꼭 기억하기!

머신러닝의 알고리즘 중 '인공신경망(ANN)'을 여러 개의 은닉층(Hidden Layer)으로 깊게(Deep) 쌓아 올린 것이 딥러닝이다.

2-1.작동 원리

출처/참고 https://starcell.github.io/ai/dl-basic/

신경망은 Input Layer(입력층), Hidden Layer(은닉층), Output Layer(출력층)로 구성

• 가중치(Weight)와 편향(Bias): 각 노드(뉴런)는 입력값에 가중치를 곱하고 편향을 더한다. 학습이란 이 가중치와 편향의 최적값을 찾아가는 과정이다.
• 역전파(Backpropagation): 출력층에서 예측값과 실제값의 오차를 구한 뒤, 이 오차를 최소화하는 방향으로 출력층에서부터 입력층으로 거꾸로 돌아가며 가중치를 업데이트(미분 활용)한다.

2-2. 활성화 함수(Activation)와 손실 함수(Loss) 설정

딥러닝은 층과 층 사이에 '활성화 함수'를 넣어 비선형성을 추가한다. 이것이 없으면 아무리 층을 깊게 쌓아도 결국 단순한 선형 회귀 모형과 다를 바가 없어진다. 은닉층에서는 주로 'relu'를 사용하여 딥러닝의 고질적 문제인 기울기 소실(Vanishing Gradient)을 방지한다.

문제 유형에 따른 출력층 설계

• 회귀 (연속된 숫자 예측):
  • 출력 노드 수: 1개
  • 활성화 함수: 없음 (또는 linear)
  • 손실 함수(Loss): mse (Mean Squared Error)
• 이진 분류 (O/X, 생존/사망 등 두 개 중 하나 분류):
  • 출력 노드 수: 1개
  • 활성화 함수: sigmoid (출력값을 0~1 사이의 확률로 변환)
  • 손실 함수(Loss): binary_crossentropy
• 다중 분류 (여러 클래스 중 선택):
  • 출력 노드 수: 분류하려는 클래스의 개수 (예: 개/고양이/새 분류면 3)
  • 활성화 함수: softmax (각 클래스에 속할 확률을 모두 더하면 1이 되도록 변환)
  • 손실 함수(Loss): categorical_crossentropy (원핫인코딩 된 경우) 또는 sparse_categorical_crossentropy (정수형 라벨인 경우)

2-4. 학습 방법론과 성능 최적화 (과적합 방지 기법)

딥러닝 모델은 파라미터가 수십만~수천만 개에 달하기 때문에, 훈련 데이터에만 완벽히 맞춰져 새로운 데이터에 취약해지는 '과적합(Overfitting)'에 빠지기 매우 쉽다. 모델의 복잡도를 제어하는 것이 핵심이다.

• 주요 학습 파라미터:

  • Epoch (에포크): 전체 데이터를 몇 번 반복해서 학습할 것인가. 에포크가 너무 적으면 과소적합, 너무 많으면 과적합이 발생한다.
  • Learning Rate (학습률): 가중치를 업데이트할 때 오차의 최소점을 향해 한 번에 얼마나 크게 이동할 것인가를 결정한다. 너무 크면 최적점을 지나쳐 발산하고, 너무 작으면 학습이 지나치게 느려지거나 지역 최적점(Local Minimum)에 갇힌다.

• 과적합 방지 및 최적화 기법:

  • Early Stopping: 모델이 학습하면서 검증 데이터의 오차(val_loss)가 더 이상 감소하지 않고 반등하기 시작하면, 설정해 둔 Epoch가 남아있더라도 학습을 강제로 조기 종료시킨다. patience 옵션으로 오차가 줄지 않아도 몇 번의 에포크를 더 기다려볼지 결정할 수 있다. 과적합으로 넘어가기 전 최적의 타이밍에 학습을 멈추는 필수 콜백 함수다.
  • ModelCheckpoint: Early Stopping과 함께 자주 쓰이며, 학습 과정 중 지정한 지표(예: val_loss)가 가장 좋았던 순간의 최적의 가중치를 파일로 자동으로 저장해 둔다.
  • Dropout: 은닉층의 노드 중 일부 비율(예: 20~50%)을 무작위로 비활성화한 채로 학습하는 방법이다. 매 에포크마다 끊어지는 노드가 달라지므로 모델이 특정 노드의 가중치에만 과도하게 의존하는 것을 막아준다. 이는 일종의 앙상블 효과를 내어 새로운 데이터에 대한 일반화(Generalization) 성능을 비약적으로 높여준다.
  • Regularization: L1 규제, L2 규제 등을 통해 가중치 값이 비정상적으로 커지는 것을 수학적으로 억제하여 모델의 복잡도를 낮추는 기법이다.

출처/참고 https://facerain.github.io/improve-dl-performance/ https://pub.towardsai.net/keras-earlystopping-callback-to-train-the-neural-networks-perfectly-2a3f865148f7 https://kh-kim.github.io/nlp_with_deep_learning_blog/docs/1-14-regularizations/04-dropout/ https://www.geeksforgeeks.org/machine-learning/regularization-in-machine-learning/

생각정리

대학원 면접 보러 갔을 당시 내가 고민하다가 생각한 주제인 Why Multi-class Classification Needs Softmax를 발표하는 장면이 주마등처럼 스쳐가는 수업이었던 거 같다... 수업내용에서는 Multi-class를 크게 다루지 않았지만 학부 연구생때 연구실에 처음 들어가 교수님이 읽으라고 지시해주신 딥러닝 모델들도 생각나게 되는 수업이었던 거 같다.

• ImageNet Classification with Deep Convolutional Neural Networks(AlexNet)
• Deep Residual Learning for Image Recognition
• Densely Connected Convolutional Networks
• Very Deep Convolutional Networks for Large-Scale Image Recognition

구조를 이해하고 최적화기법에 하나하나에 수식을 보는 것이 아닌 전체 흐름 구조 복습 및 실질적인 AICE-associate를 준비하기 앞서 코드를 직접 작성해 보고 구현해 보는 것이 목적이었다고 생각한다. 기간이 너무 짧다 보니(2일/2일) 비전공자/전공자에게 모든 것을 이해시키는 것은 정말 불가능하다고 생각했었기 때문이다. 하나의 내용으로만 2주 내내 수업해도 모자라지 않은 내용이었다고 생각한다. 실습과 복습을 진행하면서 수업 시간에 내용에서 강사님께서 설명해 주신 부분이 맞나?라고 생각했던 부분을 다시 찾아 보면서 이해할 수 있었던 좋은 시간이었다고 생각한다. 배웠던 내용이 오래 기억되고 나의 지식으로 온전히 다 받아들일 수 있게 "반복 학습하자!" 생각을 하며 2주차를 마무리한다.

교수님(대학교 지도교수님)의 말씀 중 : 내가 배운 내용을 정말 이해하고 있는지 의문이 들 때가 있어, 그럴 때는 그 내용을 다른 이에게 설명하고, 상대방에게 설명할 수 있다면 비로소 그것이 내 것이 된 지식일 거야

Github-Private

회고록은 자고로 1주일을 마무리며 쓰는 게 제일 효과적이라고 생각했다.. 그렇게 생각했지만.. 미루고 미루다 보니 4주 차가 끝나는 시점에 블로그로 기록을 남기게 되었다. 아주 부끄럽지만 지금부터라도 수업이 끝난 주 주말에 1주일에 회고록을 담아 내가 생각하고 배웠던 내용을 생생히 담아보려고 한다.

1주차

자기소개/인사말

간단하게 입교식 및 AIVLE-EDU 사용법에 대해 매니저님께서 설명해 주셨다. 수업내용과 자료는 AIVLE-EDU사이트에서 다운로드해 활용하고 Teams를 이용해 5,6반 에의 블러 팀원들과 매니저님과 소통할 수 있게 되었다. 1주 차에서는 깃허브 사용법과 Colab-Python 데이터 전처리를 간단하게 배웠다. 복습을 해보자 (깃 README.md에 정리된 내용)

Pandas DataFrame 데이터 처리

1. 데이터프레임 인스턴스 생성 및 데이터 로드

데이터 분석의 초기 공정은 다양한 소스의 원천 데이터를 Pandas의 핵심 객체인 Series 또는 DataFrame으로 적재(Loading)하는 과정이다.

데이터프레임의 직접 정의

import pandas as pd

# 데이터 본체(data), 행 식별자(index), 열 명칭(columns)을 명시하여 객체를 생성함
df = pd.DataFrame(data=data_source, index=idx_list, columns=col_list)

외부 데이터셋 가독 (CSV)

# index_col: 특정 열을 데이터프레임의 인덱스로 지정함
# header: 열 이름이 포함된 행의 번호를 지정하며, 부재 시 None으로 설정함
df = pd.read_csv("path/to/data.csv", index_col='Date')

2. 데이터 탐색 및 기술통계 (Exploration & Descriptive Statistics)

데이터의 물리적 구조, 자료형, 분포 및 결측치 현황을 파악함으로써 이후 전처리 전략의 기초를 수립하는 정찰 단계이다. 구조 및 메타데이터 참조

• df.head(n) / df.tail(n) : 데이터셋의 상위 및 하위 표본을 추출

• df.shape : 데이터프레임의 차원(행과 열의 개수)을 확인함

• df.info() : 인덱스 구성, 각 열의 자료형(dtypes) 및 비결측치(Non-Null) 개수 등 전체 요약을 출력함

• df.columns / df.index : 열 명칭 및 행 인덱스 정보를 참조함

• df.values : 내부 데이터를 Numpy 다차원 배열 형태로 반환함

통계적 특성 및 분포 파악

• df.describe() : 수치형 데이터에 대한 주요 기술통계량(평균, 표준편차, 사분위수 등)을 요약함

• df['col'].value_counts() : 범주형 데이터의 각 항목별 출현 빈도를 산출함

• df['col'].unique() / nunique() : 고유값의 목록 및 고유값의 총 개수를 확인함

• df['col'].mode() : 데이터셋 내 최빈값을 산출함

• df.sum(), df.mean(), df.median(), df.std() : 산술 합계, 평균, 중앙값, 표준편차 등 통계 함수를 적용함

3. 데이터 조회 및 필터링 (Selection & Filtering)

특정 분석 목적에 부합하는 서브셋(Subset)을 추출하기 위한 다양한 인덱싱 기법을 포함한다. 데이터 인덱싱 및 정렬

차원 선택

- df['col'] : 단일 열 추출 시 Series 객체가 반환됨

- df[['col1', 'col2']] : 다중 열 추출 시 리스트를 사용하여 DataFrame 형태를 유지함

조건부 조회 및 위치 기반 조회

- df.loc[row_condition, col_name] : 레이블 기반 조회 방식으로, 불리언 인덱싱(Boolean Indexing)을 통한 조건부 필터링에 최적화됨

- df.iloc[row_idx, col_idx] : 정수 위치 기반 조회 방식으로, 행과 열의 물리적 순서에 따라 데이터를 추출함

- df.isin([list]) : 특정 열의 값이 주어진 리스트 내에 포함되는지 여부를 판단하여 필터링함

정렬 프로토콜

- df.sort_values(by=['col1', 'col2'], ascending=[True, False]) : 복수의 열을 기준으로 정렬 방식을 개별 적용할 수 있음

4. 데이터프레임 구조의 변형 (Structural Modification)

열(Column) 및 행(Row) 관리

식별자 변경: df.rename(columns={'old': 'new'}, inplace=True)를 통해 특정 열의 명칭을 수정한 후 원본 객체에 직접 반영함

열의 추가 및 삽입:

- df['new_col'] = values : 데이터프레임의 최우측에 새로운 열을 추가함

- df.insert(pos, 'name', values) : 지정된 위치(pos)에 특정 열을 삽입하여 구조를 정밀하게 제어함

제거 프로세스:

- df.drop(list, axis=1, inplace=True) : 명시된 열 리스트를 제거함 (열 삭제 시 axis=1 설정 필수)

- df.pop('col') : 특정 열을 반환함과 동시에 원본 데이터프레임에서 영구히 삭제함

인덱스 재설정: df.reset_index(drop=True, inplace=True)는 기존 인덱스를 제거하고 연속적인 정수 인덱스로 초기화하는 공정으로, 데이터 결합 후 인덱스 정합성 확보를 위해 수행함

5. 데이터 가공 및 변환 (Transformation & Mapping)

데이터의 유효성을 확보하고 분석에 용이한 형태로 값을 변환하는 과정이다.

- replace() : 스칼라 값을 탐색하여 지정된 값으로 정밀하게 치환함

- map() : 딕셔너리 또는 함수를 매개로 Series의 개별 요소를 일대일 대응 변환함 (범주형 데이터 인코딩 시 유용함)

- pd.cut() : 수치형 연속 변수를 지정된 경계값에 따라 범주형 데이터로 이산화(Discretization)함

6. 결측치 관리 (Handling Missing Values)

데이터의 완전성을 저해하는 결측값(NaN)에 대한 체계적인 처리 방안을 명시한다.

• 현황 파악: df.isna().sum() 또는 df.isnull().sum()을 통해 열 단위 결측치 발생 빈도를 집계함

• 제거 전략: df.dropna(subset=['col'], axis=0, inplace=True)를 실행하여 특정 핵심 변수에 결측이 존재하는 레코드를 제외함

• 보간 및 대체: df.fillna(value) 또는 전방/후방 보간법(method='ffill'|'bfill')을 적용하여 결측값을 통계적 추정치로 대체함

7. 데이터 집계 및 그룹 연산 (Aggregation & Grouping)

특정 기준 열을 중심으로 데이터를 그룹화하여 고차원적 통계 정보를 추출하는 방법론이다. Groupby 연산

분할(Split)-적용(Apply)-결합(Combine) 패러다임을 통해 그룹별 분석을 수행함.

# 범주별 타겟 열에 대해 다중 통계량(합계, 평균 등)을 동시에 산출함
df.groupby('Category', as_index=True)['Target'].agg(['sum', 'mean'])

8. 데이터프레임 병합 및 연결 (Merging & Concatenation)

다양한 출처에서 기인한 데이터를 단일 데이터프레임으로 통합하는 고도화된 결합 기법이다. 물리적 연결 (Concat)

- axis=0 : 수직 방향 연결을 수행하며, 인덱스 중복 여부를 고려하여 reset_index를 병행할 것을 권장함

- axis=1 : 수평 방향 연결을 수행하며, 조인 방식(join='inner'|'outer')에 따라 데이터 유지 범위가 결정됨

논리적 병합 (Merge)

관계형 데이터베이스의 Join 연산과 유사하게 공통된 키(Key) 컬럼을 기준으로 데이터를 병합함.

- how='inner' : 양측 데이터프레임에 공통으로 존재하는 키값만을 추출함

- how='left' / 'right' : 좌측 또는 우측 데이터프레임을 기준으로 데이터를 유지하며, 대응값이 없는 경우 NaN으로 처리함

- how='outer' : 모든 데이터를 보존하는 완전 외부 조인을 수행함

생각정리

깃허브를 배우는 수업에서 VScode-Git-graph 이용법에 대해 배웠던 점이 인상 깊었다. 항상 터미널로 작업하던 입장으로써 눈으로 직관적으로 brnach들을 볼 수 있다는 점 그리고 간단하게 클릭으로 Checkout, Merge, Rebase, Reset, Revert 등을 적용할 수 있다는 점이다. 유용하게 프로젝트를 진행할 때 사용할 거 같았다. (코드 리뷰할 때도 편할 거 같았다)

데이터 전처리 코드를 수없이 봐왔던거 같다(캐글, 자격증 준비, 전공) 이번 1주차에서는 기본적인 내용으로 짧고 빠르게 많은 함수에 사용법을 알아가는 시간이었던 거 같다. 수업 시간이 09~18시까지 온라인으로 이어지다 보니 아침에 일어나 적응하는 시간이 아직 익숙해지지 않았던 거 같다. 날마다 체크인과 체크아웃 시간에 자기소개 시간을 가지며 같은 반 에이블러님들이 어떤 목표로 부트 캠프에 참여하게 된 걸 알게 되어 좋았던 거 같다. (같은 목표를 바라보는 에이블러님들이 많았던 거 같다) 자기소개 이외에 교육을 진행하는 동안 미래의 나에게 전하는 시간이 있었는데 (코딩테스트 업그레이드, 공모전 수상, 개근하기 등등)그 말을 이룰 수 있도록 열심히 임해 후회 없는 시간들을 보냈으면 좋겠다고 생각하며 1주 차를 마무리한다.

강사님의 말씀 중 "하루살이라고 생각하고 오늘 하루의 최선을 다하세요!"

Github-Private

들어가며

이번 글은 늦게나마 시작하게 된 에이블스쿨 합격 후기 글이자 에이블 스쿨에 회고록/배운내용정리를 쓰게 될 첫 글이다. 방학 동안 개인적으로 코딩 테스트 공부와 기업들에 채용공고들을 보며 나에게 부족한 점과 기업이 원하는 개발 언어, 툴, 경험을 쌓는 데에 초점을 두고 2026년에 계획을 세우고 있었다. KT-에이블 스쿨에 모집 글은 학교 내 포스터와 KT 디지털 인재 장학생을 마치며 단체 톡 방에도 모집 글이 올라왔었다. 나는 개발자 부트캠프에 참여했던 여러 선배들에 이야기를 듣기도 하고 구글링을 하며 XX부트캠프 1주차 회고록이라는 여러글도 봤었는데, 여러 부트 캠프 중 기업에 이름을 빌려 하는 부트 캠프들 - ( 삼성 SSAFY, 네이버 부스트 캠프, 우아한테 그 코스, LG Aimers, 카카오 테크 캠퍼스, 현대모비스 SW 아카데미, 포스코 AI · Big Data 아카데미 등등) 중 수료 후 KT 취업연계 지원과 우수 수료생일 경우 채용 지원 시 우대가 된다는 점, 그리고 과거 에이블 기수 후기에 코딩 테스트를 함께 리뷰하며 많이 성장한 후기, 여러 스터디 모임이 활성화되어 있다는 글을 보고 좋은 사람들과 함께 성장할 수 있는 좋은 기회라고 생각해 9기 모집에 지원했다. (글쓴이도 현재 공모전/코딩 테스트 스터디 모임에 활발히 참여 중입니다! 나중에 기록 남길게요..)

9기 지원 절차

위 사진에서 보이듯 모집분야는 크게 AI 개발자(트랙)과 DX 컨설턴트(트랙)이 나눠져있다. 컨설팅에도 관심이 있었지만 지금까지 배워왔고 조금 더 익숙하다고 생각한 개발 쪽에 가까운 AI 개발자 트랙으로 지원하게 되었다.

• 서류절차 : 최종학력/자격증/대외홛동/자신이 생각한 언어 레벨/지원 동기 등을 작성해야 했던 거 같다. 자신이 했던 활동들을 잘 녹여서 솔직하게 작성하는 것이 중요하다고 생각한다. AI도움받아서 글을 작성하지말고 내가 한 활동들과 지원동기를 자기 손으로 작성하자! (도움이 될지 모르겠지만 나는 내가 과거에 진행했던 활동들을 깃허브나 노션에 이미 정리가 돼있어 URL도 같이 제출했다.)

• 역량검사 : 서류 합격 후 등록한 이메일로 역량검사에 대한 정보를 자세히 설명해 준다. 안내된 사이트 중 AI 역량검사로 온라인 테스트로 진행하게 되는데 같은 환경에서 연습할 수 있는 기회도 5번 제공하니 테스트 진행 전 연습을 충분히 하고 테스트를 보면 된다. (역량검사 기간도 9일 정도 주기 때문에 시간, 공간 제약 없이 역량검사를 진행하자)

• 참고로 과거 에이블스쿨 AI트랙에 경우 따로 코딩테스트를 진행했어야했는데 9기 지원에서는 AI/DX 공통으로 AI역량검사만을 진행하면된다.*

  공부할때 참고한 유튜브지만 많은 자료가 있으니 더 참고해서 테스트 진행해보세요! 신유형 도형 기억하기 : https://www.youtube.com/watch?v=QMUhmIi_X2k&t=194s 길 이어만들기 : https://www.youtube.com/watch?v=UDYLBG__Jeg 도형회전하기 : https://www.youtube.com/watch?v=ozWnwQifWPk&t=149s 마법약 만들기 : https://www.youtube.com/watch?v=qTKFQYPUg2Y

• 합격발표/교육시작 : 최종 결과 발표 후 이메일로 입교 정보, 에이블 스쿨 공식인스타그램, 오픈 카톡 방, K-DT 참여 규정 및 설명회를 진행하니 안내사항에 따라 잘 준비하고 교육을 시작하면 된다. (기간도 넉넉하고 안내사항을 이메일, 카카오톡, 문자로 안내 주시니 못따라가면 바보...)

마치며

KT-AIVLE을 지원하려고 하는 사람들에게 도움이 되었으면 해서 글을 작성했다. 큰 내용 없이 너무 단순한 글이지만 궁금한 점은 (기수 모집당시)AVILE 스쿨 오픈카톡방 또는 공식 홈페이지 FAQ를 이용하면 도움을 받을 수 있을 것이다. (또는 댓글 남겨주시면 제가 알고 있는 지식에서 도와드리겠습니다)

글쓴이는 9기 AI 트랙 수도권 5반에 배정받았습니다.

부록

AIVLE 스쿨에 입교하게 되면 교육기간 동안 사용할 노트북을 개인 모두에게 제공해 주니 참고! (교육 시 필요한 프로그램들을 설치 필요 없이 모두 준비돼있음)

듀얼 모니터로 연결해 잘 사용 중입니다.

Velog에서 마지막글을 작성했던 2025년 6월 기점으로 약 10개월이 지나갔다. (옵시디언, 노션으로 기록을 했기 떄문에 밀렸던게 당연한가..) 그시간동안 많이 도전하고 실패도 느껴봤던거 같다. 졸업하기전 내가 원하던 목적지에 최종 도달하는데 실패했지만 하나씩 나의 기억을 정리하며 이제부터 다시 Velog로 돌아와 기록하고자 한다.

2025년 마지막 여름 방학

정말	감사했습니다!

2025년에 여름방학은 나의 본가인 부천에서 보내지 않고 학교 연구실에 출근해 9 to 6을 지키려고 노력했다. 교수님이 방학 동안은 학부수업이 없으니 훨씬 여유롭고 자신이 집중하면 연구, 개인공부 등 하고싶은 공부를 하면 모든 것을 이뤄낼 수 있다고 응원도 해주셨다. (연구실에 있는 학부연구생, 석사생분들) 모든 사람들이 같이 학습하고 회의할 수 있는 장을 보낼 수 있게 RAG, LLM 공부 회의 및 논문세미나를 진행해 혼자 학습만을 하는 것이 아닌 함께 학습할 수 있어 보다 수 훨씬 하게 공부할 수 있었던 거 같다.

방학 동안에 있던 가장 뜻깊은 경험이라면 내가 너무 감사하게도 학교 등록금을 전액 받으면서 다닐 수 있었던 KT 디지털 인재 장학생으로써 KT 직원들과의 팀 프로젝트가 있었다. 조원은 학생들끼리만 배정되고 피드백을 각 독방에 멘토님이 계셔서 우리가 궁금한 점 어떤 점이 부족한가에 대한 가차없는 피드백을 받을 수 있었다. 우리 조는 총 4명으로 내가 조장으로써 좋은 성과를 내기위해 열심히 노려했던거 같다. Notion-Team Project - 11 천안재생센터와 미팅을 진행하며 요구사항을 듣고 우리가 천안재생센터가 필요하다고 생각하는 웹 또는 앱에 대한 주제를 선정해 결과물을 만들어 1박 2일 워크숍도 잘 다녀왔다. 내가 대학생인 신분에서 쉽게 경험하지 못할 이 감정을 선물해주신 KT-SEG 경영팀, 임직원분들, 그리고 멘토로 활동해주신 KT-Model Prototype, LLM, Cloud팀 멘토님들에게 감사인사를 전합니다.

추가로

• 정보통신산업진흥원이 운영하는 2025-오픈소스 컨트리뷰션 아카데미 [Pytorch 문서화 번역] 파트 멘티에 참여하게 되어 2학기에 진행할 예정이다.
• 빅데이터분석기사 실기에 합격해 자격증 +1
• KT-AI 생성형AI 영상부문 공모전 입상 +1
• 백준 골드5 달성

2025년 마지막 학기를 보내며

대학교 4-2학기인 마지막 학년을 보내며 주위친구들 중 이제 자리를 잡아가는 친구들도 하나둘씩 생기게 되었다. 대기업, 여러 인턴을 도전하는 친구들, 전공을 포기하고 다른 일자리를 찾으며 공인어학성적을 준비하는 친구들 중견, 중소에 취업해 졸업 전에 자기의 뜻을 이룬 친구들 등 나도 나 자신이 노력하고 있다고 생각하고 하루를 뜻깊게 살았지만 나보다 더 노력하고 열심히 하는 주위친구들이 많았었다고 생각한다. 나의 마지막 학기에 끝은 학부연구생을 하며 좋아하던 연구가 생겼었고 그 분야에 도전하기 위해 ist계열 대학원에 지원했었다. (서울권 대학원은 아무리 그래도 등록금에 대해 너무 부담스럽다고 생각했다.)

면접	졸업작품

(디지스트, 지스트, 유니스트)과학기술원에 도전하였고 지스트는 서류가 떨어졌지만 유니스트와 디지스트는 서류에 합격해 면접을 볼 좋은 기회가 생겼었다. 각 대구와 울산에 있으며 나의 학교인 충주에서 출발해도 하루를 학교 공결내고 왕복해도 부족할 만큼 거리가 좀 멀었던 기억이 남는다. 두 가지의 면접 모두 제공해준 지침과 구글링을 통해 어느 정도 감을 잡고 있었지만, 영어로 발표와 대답을 할 수 있다는 점이 나에게는 큰 한계였던 거 같다. 내 나름대로 짧은 기간 동안 모든 심혈을 기울여 집중하고 밤새고 대본 외우고 학교, 집에서 PT 연습을 많이 했었지만, 결과는 둘 다 떨어졌다. (교수님 컨택이 늦은 점도 있으며 면접 당시 1지망에 지원했던 교수님에게만 메일이 오지 않았지만, 면접에서 1지망 교수님이 있어서 매우 당황했던 기억이 있다.) 떨어지고 나서 미리 완성했었던 졸업작품 발표도 전시회도 그럭저럭 마무리하며 내가 2년 동안 함께했던 컴퓨터공학과 학생회 사람들과 나의 학교생활을 마무리했던 거 같다. (학부연구생 연구 할당에 집중하지 못한 내가 아쉽네..)

추가로

• 정보처리기사 합격으로 자격증 +1
• 학교 내 Mircro_Degreee - 인공지능전문가양성과정 수료
• OSSCA-오픈소스-Pytorch 멘티 활동 수료
• AI-FSESTA 컨퍼런스 참여

  • 2025 GIT

2026

사진이 많아서..	다른 이들 생략해서 미안

졸업식, 연구실정리, 부트캠프, 다시 대학원 컨택 등 내가 무엇을 해야할지, 나아갈 내 자신이 두려웠다. 사실 대학원에 떨어졌던 충격이 제일 크기도 했지만 내가 제일 잘하는 것이 무엇일까, 내가 노력했던 분야를 끝까지 물고가면 성공, 합격할 수 있을까 생각했다. 종강하고 3년동안 머물렀던 자취방을나와 오랜만에 나의 본가에 도착했다. 그동안 밀렸던 잠도 자고 국외여행도 다녀왔다. 졸업이기에 급한 마음도 있었지만 다시 오지 않을 26살이자 회사 또는 다른 일을 시작하게 된다면 이럴 시간도 없을 것이라 생각했다. (생각해보니 베짱이 마인드네) 놀기도 놀지만 매일 코딩테스트 문제나 내가 관심 있었던 머신 러닝, computer vision, 3D 그래픽 기사나 책도 가끔 읽는다. 이건 순순히 재밌기도 했고 밤새우면서 내가 무엇 가에 오랫동안 몰두했던 기억이 남아서이기도 한 거 같다. 하루를 낭비하지 않고 살아가는 것 그렇게 살기 위해 오늘 다시 시작해보려고 한다.

포기하지말자

목차

• 파트 4: CART: 분류 트리 (Classification Tree)
• 파트 5: CART: 회귀 트리 (Regression Tree)
• 파트 6: 모델 일반화 평가 & 교차 검증
• 파트 7: Bagging
• 파트 8: AdaBoost
• 파트 9: Voting Classifier
• 파트 10: Random Forest Regressor

파트 4. CART: 분류 트리 (Classification Tree)

# 페이지 15
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 데이터 분할 (80% train, 20% test)
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    stratify=y,
    random_state=1
)

# 모델 선언 & 학습
dt = DecisionTreeClassifier(criterion='gini', random_state=1)
dt.fit(X_train, y_train)

# 예측 & 평가
y_pred = dt.predict(X_test)
print(accuracy_score(y_test, y_pred))

파트 5. CART: 회귀 트리 (Regression Tree)

# 페이지 20
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error as MSE

# 데이터 분할 (80% train, 20% test)
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=3
)

# 모델 선언 & 학습
dt = DecisionTreeRegressor(max_depth=4, min_samples_leaf=0.1, random_state=3)
dt.fit(X_train, y_train)

# 예측 & 평가 (RMSE)
y_pred = dt.predict(X_test)
rmse = MSE(y_test, y_pred) ** 0.5
print(rmse)

파트 6. 모델 일반화 평가 & 교차 검증

# 페이지 21-23
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import mean_squared_error as MSE

# 설정
SEED = 123

# 데이터 분할 (70% train, 30% test)
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.3,
    random_state=SEED
)

# 모델 선언
dt = DecisionTreeRegressor(max_depth=4, min_samples_leaf=0.14, random_state=SEED)

# 10-fold CV MSE 계산
mse_cv = -cross_val_score(
    dt, X_train, y_train,
    cv=10,
    scoring='neg_mean_squared_error',
    n_jobs=-1
)

# 학습 & 예측
dt.fit(X_train, y_train)
y_train_pred = dt.predict(X_train)
y_test_pred = dt.predict(X_test)

# 결과 출력
print('CV MSE:', mse_cv.mean())
print('Train MSE:', MSE(y_train, y_train_pred))
print('Test MSE:', MSE(y_test, y_test_pred))

파트 7. Bagging

# 페이지 8-9, 15
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

SEED = 1

# 데이터 분할 (70% train, 30% test)
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.3,
    stratify=y,
    random_state=SEED
)

# 기본 모델 선언
dt = DecisionTreeClassifier(max_depth=4, min_samples_leaf=0.16, random_state=SEED)

# Bagging 모델 선언 (n_estimators=300)
bc = BaggingClassifier(
    base_estimator=dt,
    n_estimators=300,
    n_jobs=-1
)

# 학습 & 예측
bc.fit(X_train, y_train)
y_pred = bc.predict(X_test)
print('Bagging Accuracy:', accuracy_score(y_test, y_pred))

# OOB 평가 (oob_score=True 설정 시)
# bc = BaggingClassifier(base_estimator=dt, n_estimators=300, oob_score=True, n_jobs=-1)
# bc.fit(X_train, y_train)
# print('OOB Accuracy:', bc.oob_score_)

파트 8. AdaBoost

# 페이지 8-9
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split

SEED = 1

# 데이터 분할 (70% train, 30% test)
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.3,
    stratify=y,
    random_state=SEED
)

# Decision Stump 선언
dt = DecisionTreeClassifier(max_depth=1, random_state=SEED)

# AdaBoost 모델 선언 (n_estimators=100)
adb_clf = AdaBoostClassifier(base_estimator=dt, n_estimators=100)

# 학습 & 예측 확률
adb_clf.fit(X_train, y_train)
y_proba = adb_clf.predict_proba(X_test)[:, 1]

# 평가 (ROC AUC)
print('ROC AUC:', roc_auc_score(y_test, y_proba))

파트 9: Voting Classifier

# 1) 라이브러리 임포트
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import VotingClassifier

# 2) 데이터 분할
SEED = 1
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.3,
    random_state=SEED
)

# 3) 기본 분류기 선언
lr = LogisticRegression(random_state=SEED)
knn = KNeighborsClassifier()
dt = DecisionTreeClassifier(random_state=SEED)

# 4) 앙상블 메타 모델 선언 및 학습
voting_clf = VotingClassifier(
    estimators=[('lr', lr), ('knn', knn), ('dt', dt)],
    voting='hard'
)
voting_clf.fit(X_train, y_train)

# 5) 예측 및 평가
y_pred = voting_clf.predict(X_test)
print(accuracy_score(y_test, y_pred))

파트 10: Random ForestRegressor

# 1) 라이브러리 임포트
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error as MSE

# 2) 데이터 분할
SEED = 1
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.3,
    random_state=SEED
)

# 3) 모델 선언 및 학습
rf = RandomForestRegressor(
    n_estimators=400,       # 트리 개수
    min_samples_leaf=0.12,  # 리프 노드 최소 샘플 비율
    random_state=SEED
)
rf.fit(X_train, y_train)

# 4) 예측 및 평가 (RMSE)
y_pred = rf.predict(X_test)
rmse = MSE(y_test, y_pred) ** 0.5
print(f'Test set RMSE of rf: {rmse:.2f}')

• 파트 1: K-Means 클러스터링
• 파트 2: 계층적 군집화 & t-SNE
• 파트 3: NMF (Non-Negative Matrix Factorization)

파트 1: K-Means 클러스터링

개념

• 데이터를 k개의 군집으로 나누는 비지도 학습 알고리즘
• 중심(centroid)을 반복 갱신하며 군집 할당

코드 스니펫

# 1) 라이브러리 임포트
import numpy as np
from sklearn.cluster import KMeans

# 2) 데이터 로드
samples = np.loadtxt('data.csv', delimiter=',')       # → 파일 경로/이름 수정

# 3) 모델 선언 및 학습
model = KMeans(n_clusters=3)                          # → k 값 수정
model.fit(samples)

# 4) 클러스터 할당
labels = model.predict(samples)
print(labels)                                         # 예: [0 0 1 1 0 1 …]

# 5) 새로운 샘플 예측
new_samples = np.array([[…], […], […]])              # → 예측할 데이터 입력
new_labels = model.predict(new_samples)
print(new_labels)

# 6) 클러스터 평가 (관성: inertia)
print(model.inertia_)                                 # 값이 낮을수록 응집도 높음

# 7) 시각화 (산점도)
import matplotlib.pyplot as plt
xs = samples[:, 0]                                     # → 사용할 차원 인덱스 조정
ys = samples[:, 1]
plt.scatter(xs, ys, c=labels)
plt.show()

파트 2: 계층적 군집화 & t-SNE

개념 계층적 군집화: 덴드로그램으로 군집 구조 파악 t-SNE: 고차원 데이터를 2차원으로 축소해 시각화

• 계층적 군집화

  # 라이브러리 임포트
  from scipy.cluster.hierarchy import linkage, dendrogram, fcluster
  import matplotlib.pyplot as plt
  

병합 연산 (linkage)

mergings = linkage(samples, method='complete') # method: 'single','average','ward' 등

덴드로그램 시각화

dendrogram( mergings, labels=country_names, # → 레이블 리스트 입력 leaf_rotation=90, leaf_font_size=6 ) plt.show()

클러스터 레이블 추출

labels = fcluster(mergings, 15, criterion='distance') # → 거리 컷오프 값 조정 print(labels)

- t-SNE
```python
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt

# 모델 선언 및 변환
model = TSNE(learning_rate=100)                       # → learning_rate 조정 (50–200 권장)
transformed = model.fit_transform(samples)

# 시각화
xs = transformed[:, 0]
ys = transformed[:, 1]
plt.scatter(xs, ys, c=species)                        # → 군집 비교용 레이블 입력
plt.show()

파트 3: NMF (Non-Negative Matrix Factorization)

개념 음수가 아닌 행렬 분해를 통해 잠재 요인(topic) 추출 문서·이미지 처리, 추천 시스템 등에 활용

# 1) 라이브러리 임포트
import numpy as np
from sklearn.decomposition import NMF
import matplotlib.pyplot as plt

# 2) 모델 선언 및 학습
model = NMF(n_components=2)                           # → 컴포넌트 수 수정
model.fit(samples)

# 3) 특징 행렬 변환
nmf_features = model.transform(samples)
print(nmf_features)

# 4) 컴포넌트 행렬 확인
print(model.components_)                              # (n_components, n_features)

# 5) 이미지 재구성 예시
bitmap = sample.reshape((height, width))              # → sample, 크기 수정
plt.imshow(bitmap, cmap='gray', interpolation='nearest')
plt.show()

# 6) 추천 시스템 적용 예시
nmf = NMF(n_components=6)                             # → 추천용 토픽 수 조정
nmf_features = nmf.fit_transform(articles)            # → articles: 문서×단어 행렬

1/9 fastapi 공부(로그인 기능 x) -> 파이썬 가상환경(.venv)연결해 예제 풀이 axios 공부 ( 로컬에서 돌려보기) mysql 공부(이걸로 서버 관리함) -> mysql 벤치 설치 후 연결 확인 orm 이용해서 예제 풀어보기 orm을 사용하여 fastapi를 어떻게 할지 공부

-> 개념 넓고 얇게 공부하기

데이터 주고 받기 정도

FastAPI란?

FastAPI는 Python으로 작성된 최신 웹 프레임워크로, 빠르고 간단하며 효율적인 API를 개발할 수 있도록 설계되었습니다. 높은 성능과 사용자 친화적인 인터페이스를 제공하여 웹 개발자들 사이에서 인기를 얻고 있습니다.

FastAPI의 주요 특징

1. 고성능

• ASGI(Asynchronous Server Gateway Interface) 기반: 비동기 처리를 지원하여 높은 처리 속도를 자랑.
• Python의 Starlette와 Pydantic을 기반으로 제작되어 경량화와 안정성 보장.

2. 자동 문서화

• FastAPI는 OpenAPI와 JSON Schema를 기반으로 자동 API 문서화를 제공합니다.
• API를 생성하면 /docs 또는 /redoc 경로에서 문서를 자동 생성 및 확인 가능.

3. 유형 검사(Type Hint) 활용

• Python의 Type Hint를 적극 활용하여 코드의 안정성과 가독성 향상.
• Pydantic을 사용해 데이터 검증과 직렬화 지원.

4. 비동기 지원

• async/await 문법을 기본적으로 지원하여 비동기 작업을 간단하게 구현 가능.
• 데이터베이스, 외부 API와의 비동기 통신에 최적화.

5. 간결한 코드

• 직관적인 문법과 코드 구조로 빠르게 API 개발 가능.
• 코드 작성이 간소화되어 생산성 증가.

FastAPI 시작하기

FastAPI를 시작하는 것은 간단하다. 아래의 명령어를 실행하여 FastAPI를 설치

설치

pip install fastapi uvicorn

간단한 예제 코드

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello, FastAPI!"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

실행

uvicorn main:app --reload

• http://127.0.0.1:8000에서 API를 확인할 수 있습니다.
• 자동 생성된 문서는 http://127.0.0.1:8000/docs에서 확인 가능합니다.

간단하게 html 연결해서 실행해보자 FastAPI로 간단한 대시보드 구현 프로젝트 설명 실행 환경

Python 버전: 3.10 이상
FastAPI: 웹 프레임워크
Uvicorn: ASGI 서버
Jinja2: HTML 템플릿 렌더링
파일 구조:

프로젝트 폴더/
├── .venv/                   # 가상환경 폴더
│   ├── Include/
│   ├── Lib/
│   ├── Scripts/
│   └── 기타 가상환경 파일들
├── static/                  # 정적 파일 저장 폴더
│   └── style.css            # 스타일 파일
├── templates/               # 템플릿 파일 저장 폴더
│   └── dashboard.html       # Jinja2 기반 템플릿 파일
├── main.py                  # FastAPI 애플리케이션 파일
└── 기타 프로젝트 관련 파일

코드 설명

# 1. main.py: FastAPI 애플리케이션 로직

from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates

app = FastAPI()

정적 파일 및 템플릿 설정

app.mount("/static", StaticFiles(directory="static"), name="static")
templates = Jinja2Templates(directory="templates")


@app.get("/", response_class=HTMLResponse)
async def read_dashboard(request: Request):
    data = {"visitors": 123, "page_views": 456}  # 샘플 데이터
    return templates.TemplateResponse("dashboard.html", {"request": request, "data": data})

핵심 기능: /static 경로에 정적 파일(style.css)을 매핑. /templates 디렉토리에서 Jinja2 HTML 템플릿(dashboard.html)을 로드. 샘플 데이터 (visitors, page_views)를 템플릿으로 전달.

dashboard.html: 템플릿 파일

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>FastAPI Dashboard</title>
    <link rel="stylesheet" href="/static/style.css">
</head>
<body>
    <h1>FastAPI 대시보드</h1>
    <div class="container">
        <p>방문자 수: {{ data.visitors }}</p>
        <p>페이지 조회 수: {{ data.page_views }}</p>
    </div>
</body>
</html>

HTML 기능: {{ data.visitors }} 및 {{ data.page_views }}는 FastAPI가 전달한 데이터를 표시. /static/style.css에서 불러온 스타일을 적용.

style.css: 정적 CSS 파일

body {
    font-family: Arial, sans-serif;
    margin: 20px;
    background-color: #f4f4f9;
    color: #333;
}

.container {
    border: 1px solid #ccc;
    padding: 20px;
    border-radius: 5px;
    background: #fff;
    box-shadow: 2px 2px 5px rgba(0, 0, 0, 0.1);
}

디자인 기능: 배경색: 연한 회색(background-color: #f4f4f9) 텍스트 색상: 어두운 회색(color: #333) 컨테이너: 박스 그림자와 둥근 모서리로 심미성 향상.

구현 과정

• Python 가상환경 생성 및 활성화 python -m venv .venv .venv\Scripts\activate # Windows
• 필수 라이브러리 설치 pip install fastapi uvicorn jinja2
• FastAPI 서버 실행 uvicorn main:app --reload
• 웹 브라우저에서 확인 URL: http://127.0.0.1:8000 CSS가 적용된 대시보드와 방문자 및 페이지 조회 수 데이터가 출력됩니다.

추가

Html, js, css를 이용해서 틀을 만들어주고 fastapi를 이용해서 http://127.0.0.1:8000/ 로컬서버에 돌린 결과이다. 우리는 결과적으로 React와 fastapi를 연결하는 것이 중요하기에 이부분을 중심적으로 다시 공부해보고 연결해봐야 하겠다.

참고하자 https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/ https://blog.joonas.io/227 https://fastapi.tiangolo.com/ko/ https://github.com/reactjs/ko.react.dev https://jongsky.tistory.com/17

이글을 끝으로 옵시디언을 활용해 글을 정리할 예정이다.

안녕하세요! 깃허브를 통해 이번에 [항해99]에서 진행하는 잔디 기부 캠페인에 참여했습니다. (위 이미지는 제가 기부를 통해 받은 인증서입니다. 🌱)

📌 깃허브

깃허브를 운영하며 올해 느낀 것은, 개발자 커뮤니티는 서로 돕고 영감을 나눌 때 가장 빛난다는 점입니다. 하나의 작은 코드가 누군가의 성장에 도움이 되고, 하나의 작은 기부가 더 나은 세상을 만드는데 기여할 수 있다는 점에서 큰 보람을 느낀 한 해였습니다. 이번 잔디 기부 캠페인은 이러한 가치를 몸소 실천할 수 있는 기회였기에, 저 역시 참여했습니다.

📌 2024년을 마무리하며

2024년은 제게 있어 여러 도전과 배움의 시간이었습니다. 개발자로서 그리고 깃허브 운영자로서, 더 나은 코드를 작성하고 더 많은 사람들과 함께 나눔의 가치를 실천하려 노력했던 한 해였죠. 돌아보면, 완벽한 해는 아니었지만 "성장했다"라는 뿌듯함이 남습니다. 그리고 올해를 마무리하며 느낀 가장 큰 교훈은, 작은 실천도 모이면 큰 변화를 만든다는 점입니다. 다가오는 2025년에도 저는 이 마음을 잊지 않고, 더 나은 개발자, 더 나은 사람으로 성장해 나가고 싶습니다. 🙌

📌 마치며

작은 실천이라도 도전하고 실천하세요. 깃허브에 잔디를 심듯, 세상에 잔디를 심고, 나눔과 성장을 만들어가는 여정에 동참해보세요. 나눔은 나 혼자만의 힘으로 이루어지는 게 아니라, 우리가 함께할 때 진정한 의미를 갖는다고 생각합니다.

#항해99 #잔디기부캠페인 #잔디기부

2024년 한 해 동안 함께 성장하고 도전한 모든 분들께 감사드립니다. 새해에도 더 큰 나눔과 성장을 이룰 수 있기를 바라며, 따뜻하고 희망찬 2025년이 되길 기원합니다. 행복한 새해 맞이하세요!

📌 KT 디지털 인재 장학생 수료식

12월 20일, KT 디지털 인재 장학생 수료식을 진행했다. 사전에 네트워킹을 할 수 있는 오픈 채팅방이 만들어졌고, 초대받아 간단한 이야기들을 나누었다. 또한, 사전 주제와 미션을 받고 현장에서 조원들과 함께 토론 후 발표하는 시간을 가졌다. (소피텔 앰배서더 서울 호텔 & 서비스드 레지던스에서 진행됨)

사전주제

Q. 최근 신체 이식에 대한 연구가 활발히 이루어지고 있는 가운데, 머리를 이식하는 연구가 진행 중입니다. 이 연구에 참여하여 만약 나의 머리를 다른 사람의 신체로 이식하였을 때 그 모습을 보고 과연 ‘나’라고 할 수 있을까요?

도착 후 각 인원에게 미션지가 제공되었다. 미션의 내용은 다음과 같았다:

1. 사전 주제에 대한 답안을 팀 보드판에 작성하기
2. 오태성 실장님, 이창준 본부장님 중 1명과 함께 포토 촬영하기
3. I AN 소감 인터뷰 영상을 촬영하기

미션 자체는 크게 어렵지 않았지만, 사전에 받은 주제에 대해 이야기하는 데 있어 아쉬운 점이 있었다. 모든 조원이 각 지역에서 왔기 때문에 시간이 맞지 않아 늦게 참여한 분들도 있었고, 충분한 대화를 나누지 못한 점이 아쉬웠다.

중간에 진행된 졸업 장학생 수료증 수여식 및 우수 장학생 시상식에서는 운이 좋게도 충주권 ICT 지원을 받아 취득한 KT_AICE 자격증 관련 상을 받았다. 자격증 덕분에 가산점을 받아 이런 상을 받게 된 것 같아 기뻤다. (쉬운 난이도로 시험을 봐서 민망하기도 했지만… 비밀로 해두자!)

호텔에서 제공된 코스 요리를 먹으며 정말 감사한 마음이 들었다. 텀블러, 지갑, 각 개인 이름이 적힌 스티커와 응원 글 등 다양한 선물도 챙겨 주셨다.

오후 시간에는 외부 강사를 초청하여 특강 및 네트워킹 시간을 가졌다. 특히 궤도님을 실제로 마주하게 되어 정말 색다른 느낌이었다. 마치 연예인을 보는 듯한 기분이 들었고, 궤도님이 전한 짧은 인공지능 역사와 현재의 방향성, 더 발전하기 위한 방법들에 대한 이야기가 매우 인상적이었다. 궤도님은 우리가 어떻게 하면 더 나은 사람이 될 수 있을지 고민해 보길 바란다는 말을 남기며 생성형 AI에 대한 많은 이야기를 나눴다. 이를 통해 나 또한 더 열심히 공부해야겠다는 생각을 하게 되었다. (시간이 타이트해서 많은 이야기를 하지 못한점과 조원사이 이야기가 원활하게 안되었고 급하게 결과만 이야기한 점은 아쉬웠다.)

기사

https://www.aitimes.kr/news/articleView.html?idxno=33332

📌 참고

💻 5조 GitHub

조별로 진행하였던 폼보드에 서로를 위해서 썼던 응원메세지

📌 연구실 인턴 지원

유니스트 U-WURF에 지원했는데 12/26일 결과가 나왔다. 선택받지 못 했다.. 따로 지원서도 작성하고 연구실교수님에게 CV양식을 맞추고 여러 PPT연구 계획서 메일을 보냈었는데 답변은 오지않았고 약100명에 학생들이 뽑혔는데 AI분야와 관련된 학생은 2명밖에 뽑히지 않았다.. (모집인원이 00으로 보았으나 교수님들에 커트라인에 미치지 못하면 잘랐다고 생각한다.. 많이 부족하고 더 노력해야지..) 다음 방학에도 기회가 있고 이번기회로 내가 부족한점이 무엇인지 다시 생각해보고 더 노력해야겠다고 생각한다. (연구 경험이 없자나..) 자대 학교내 연구실을 들어가고 싶어 교수님에게 따로 메일을 보낼 예정이다.

📌 앞으로 해야할것

지금 당장 내가 무엇을 해야할지 정해야하는데... 오랜에 본가 부천을 오니 못봤던 친구들도 보고 부모님도 뵙고 하니 7일이라는 시간이 금방 지나간거같다. 토익, 토스도 딸것이고 공모전도 학교 형과 같이 이야기 한 부분이 있어 참여하고 내 개인 사이드 프로젝트도 진행하고 블로그도 중간중간 작성할 것이고 충주권ICT에서 지원해주는 교육사업도 들으면서 방학을 보낼거같다. 그 중 학교 교수님에게 메일을 보내서 연구실에 들어가 사람들과 프로젝트를 진행하는것이 제일 좋다고는 생각하지만... 하루를 후회없이 살고 더 나은 내일이 되기 위해 노력하자. 열심히 살고 좋은 결과가 나오는 2025년이 될 수 있도록.

2024 잔디

Galton의 데이터

• 패키지 UsingR
• 데이터 galton에는 부모의 키, 자식의 키에 대한 927개의 관측치가 있다.
• 부모의 키는 (아버지의 키 + 1.08*엄마의 키)/2
• 자료출처는 여기에

상관분석과 회귀분석

• 상관분석 두 연속변량 사이에 상관관계가 있는지의 여부
• 회귀분석 두 연속변량 사이에 함수 관계를 찾고, 예측할 수 있는 모형 찾기
• 단순선형회귀분석 설명변수가 1개인 직선 모형
• 다중선형회귀분석 설명변수가 여러 개인 일차 모형

📌 상관계수 성질

• 상관계수는 두 연속변량 X, Y의 선형 관계를 나타내주며 −1≤𝑟≤1이다.
• 𝑟>0일 때, X가 증가함에 따라, Y도 증가하는 경향이 있다.
• 𝑟<0일 때, X가 증가함에 따라, Y는 감소하는 경향이 있다.
• 𝑟=1이면, 모든 데이터가 기울기가 양수인 직선 위에 있다.
• 𝑟=−1이면, 모든 데이터가 기울기가 음수인 직선 위에 있다.
• 𝑟=0이면 선형관계가 없다.

💻 데이터 - 대리점의 광고비와 판매수익과의 관계

c <- c(2,3,6,4,7,4,8,6)
s <- c(8,9,10,17,21,14,27,22)

df <- data.frame(cost=c, sales=s)

cor(df)

A matrix: 2 × 2 of type dbl cost sales cost 1.0000000 0.8167395 sales 0.8167395 1.0000000

library(ggplot2)

p <- ggplot(df, aes(cost, sales))
p + geom_point(size=3, color='blue')

cor.test(df$cost, df$sales)

Pearson's product-moment correlation data: df$cost and df$sales t = 3.4672, df = 6, p-value = 0.01335 alternative hypothesis: true correlation is not equal to 0 95 percent confidence interval: 0.2640181 0.9656486 sample estimates: cor 0.8167395

• 상관계수는 0.9550718

• 귀무가설: 상관계수는 0이다.

• p-value는 0.0002192로 유의수준(0.05)보다 작으므로 유의하다.

• 상관계수가 0이라는 귀무가설을 기각.

• 즉, 상관계수는 0이 아니라고 할 수 있다.

📌 회귀분석(regression)

• 두 변량 X, Y 사이의 관계를 가장 잘 나타내주는 함수식 𝑦=𝑓(𝑥)을 찾아 modelling을 하고, 예측값을 구하는 과정
• 여기서 함수 𝑓(𝑥)가 일차식인 경우를 선형회귀분석이라 한다.
• 종속변수(반응변수) Y에 영향을 미치는 변수(독립변수)가 1개일 때, 단순회귀분석이라 한다.
• 특히, 독립변수가 1개이고 일차식인 경우를 단순선형회귀분석이라 한다.

회귀직선 – 모델링 -> 예측치

• 회귀직선의 방정식은 𝒚=𝟑𝒙+𝟐로 이는 광고비가 1(백만원) 늘어나면, 판매수익이 3(천만원) 늘어난다는 것을 의미한다.
• 예측치: 예를 들어 광고비가 5(백만원)이라면 예상되는 판매수익은 𝟑×𝟓+𝟐=𝟏𝟕(천만원)

library(ggplot2)

p <- ggplot(df, aes(cost, sales))
p + geom_point(size=3, color='blue') + geom_smooth(method = 'lm', formula = 'y~x')

reg <- lm(sales ~ cost, data=df)
reg
# 회귀분석
summary(reg)

Call: lm(formula = sales ~ cost, data = df)

• Coefficients: (Intercept) cost

  2.333        2.733  

• lm(종속변수 ~ 독립변수)

• 단순선형회귀 분석의 결과 y절편은 2, 기울기는 3

• R 제곱(결정계수)의 값은 0.9122

• 결정계수의 값이 1에 가까울수록 모형이 적합

📌 R을 이용한 회귀분석 – lm(), 회귀직선그리기

• 예측치(fitted.values) 회귀직선 상의 값
• 잔차(residuals) 관측치와 예측치의 차

회귀직선그리기

• 회귀직선의 계수는 reg$coefficients에

• 첫번째가 y절편

• 두번째가 기울기

• geom_abline()은 직선을 y절편과 기울기로 그려주는 함수

• 회귀직선의 계수는 reg$coefficients에

• 첫번째가 y절편

• 두번째가 기울기

• geom_abline()은 직선을 y절편과 기울기로 그려주는 함수

  |

• -| --|

잔차 산점도

• 잔차의 산점도가 일정한 패턴을 나타내면 모형 부적합
• geom_hline()은 수평선

예측치 구하기 – predict()

• 예측치
• cost가 5일 때의 예측치는 17
• cost가 10일 때의 예측치는 32
• lm(df$y ~ lm$x)를 사용하면 predict에서 에러가 남

🚀 주의

회귀분석 lm 사용시 lm(y ~ x, data=df) 위와 같이 하지 않으면 예측치를 구하지 못함

📌 결과해석

• 회귀직선의 방정식: 𝒚=𝟐+𝟑𝒙

• 광고비가 1(백만원) 늘어나면, 판매수익이 3(천만원) 늘어난다는 것을 의미한다.

• 예측치: 광고비가 5(백만원)이라면 예상되는 판매수익은 𝟐+𝟑×𝟓=𝟏𝟕(천만원)이다.

  ---

  📌 비선형 회귀 분석

?women

산점도

• 산점도 및 상관계수
• 상관계수는 0.995로 1에 매우 가까움

회귀분석, 회귀곡선 직선그래프, 잔차그래프

• y절편은 -87.5
• 기울기는 3.45
• R제곱은 0.991
• R제곱은 적절한 것으로 보임
• 잔차의 그래프가 감소하다 증가하는 패턴을 보임.
• 모형 부적합

이차모형, 회귀곡선 곡선 그래프, 잔차 그래프

𝑦=𝛽_0+𝛽_1 𝑥+𝛽_2 𝑥^2+𝜖

• I( ) 함수를 이용하여 이차항 추가
• 상수항: 261.8
• 일차항: -7.34
• 이차항: 0.08
• R 제곱 = 0.9995

데이터 마이닝의 이해

• 데이터마이닝(data mining)은 대용량의 데이터로부터 자동 또는 반자동적인 방법으로 의미있는 패턴, 규칙, 관계를 찾아내는 것
• 데이터 자체의 분석 단계를 넘어 패턴 추출
• 수작업의 어려움 -> 데이터마이닝의 발달

데이터 마이닝의 특징

• 데이터(베이스)의 내용을 및 결과를 단순 활용에서 벗어나 데이터에 내재해 있는 패턴 추출
• 데이터의 양이 방대해지면서 수작업이 어려움
• 데이터 마이닝의 필요성 대두
• 데이터 마이닝은 사용자의 경험이나 편견을 배제하고 전적으로 데이터에 기반하여 패턴 추출

활용분야

• 카드사의 사기 발견 프로세스
• 금융권의 대출 승인
• 투자 분석
• 기업의 마케팅
• 순수 과학 분야의 자료 분석

기법

• 군집분석
• 의사결정나무
• 연관관계 분석 기법
• 인공신경망 기법
• 회귀분석
• 사례 기반 추론
• 텍스트 마이닝
• 오피니언 마이닝

💻 패키지

library(GGally) library(factoextra) library(rpart) library(rpart.plot) library(caret) library(KoNLP) library(wordcloud)

📌 군집분석(Cluster Analysis)

변수 또는 개체(item)들이 속한 모집단 또는 범주에 대한 사전정보가 없는 경우에 관측값들 사이의 거리(또는 유사성)를 이용하여 변수 또는 개체들을 자연스럽게 몇 개의 그룹 또는 군집(cluster)으로 나누는 분석법

📌 K-means Clustering

집단을 K 개의 그룹으로 나누는 방법

자료출처: http://norman3.github.io/prml/docs/chapter09/1.html

📌 유사도

• 유클리드 거리 2차원: 두 점 (𝑥_1,𝑥_2 ), (𝑦_1, 𝑦_2) 사이의 거리√((𝑦_1−𝑥_1 )^2+(𝑦_2−𝑥_2 )^2 ) n차원: 두 점 (𝑥_1,⋯, 𝑥_𝑛 ), (𝑦_1, ⋯, 𝑦_𝑛) 사이의 거리(∑▒(𝑦_𝑖−𝑥_𝑖 )^𝑛 )^(1/𝑛)

• 코사인(cosine) 유사도 두 벡터(vector)가 이루는 각의 코사인 값cos⁡(𝑥,𝑦)=(𝑥⋅𝑦)/(|(|𝑥|)| ||𝑦||)

💻 실습 데이터 - iris

꽃잎의 너비와 길이의 산점도

• 색상을 종(Species)에 따라 다르게
• 점 모양도 종에 따라 다르게
• 크게 3개의 그룹으로 나뉘어짐

📌 petal 자료만 사용하여 분류 - kmeans()

• petal 자료만 추출
• 원데이터 알고 있음
• Length와 Width를 이용하여 Species를 분류하고 그 결과를 비교할 예정
• kmeans(데이터, centers=n, iter.max=회수)
• petal[1:2]로 Length와 Width만 사용
• centers=3: 3개의 중심
• iter.max: 반복횟수
• 결과는 실행시 마다 다르게 나타날 수 있음

kmean 결과는 리스트

• 3개의 중심 좌표 확인
• 3개의 그룹에 각각 50, 52, 48개로 분류
• 분류 그룹은 cluster에 저장됨

📌 petal 자료만 사용

• 이차원표 결과:
• setosa는 정확히 분류
• versicolor는 2개 오분류
• virginica는 4개 오분류
• 결과는 실행시마다 달라질 수 있음

중심 확인

• 각 군집(cluster)의 중심(center)도 그림에 추가
• centers를 data frame으로 저장한 후 그래프를 그림.

군집별 평행 좌표 그림, 타원그림

• 패키지 GGally 필요
• 데이터는 petal
• 사용 키는 1, 2 열
• 각 자료들이 어떻게 분류되어 있는지 확인 가능
• 패키지 factoextra 필요
• 군집별 타원으로 visualization

📌 의사결정 나무(decision tree)

• 의사결정나무는 데이터마이닝의 주요 기법 중 하나

• 분류 및 예측에 사용되는 기법
• 사용이 용이하고 결과 해석 수월
• 규칙 셋(set)으로 표현 가능

주요 변수의 선정이 용이

비연속성 및 나무형성의 한계

💻 실습_iris 데이터

의사결정나무 규칙 구하기

• 라이브러리 rpart 사용
• 150개의 데이터를 훈련 데이터로 모두사용
• Species ~ .: 에서 종(Species)는 알고 있는 결과, .은 모든 변수 사용하라는 뜻
• 주어진 결과는 규칙
• 라이브러리 rpart.plot 사용

의사결정나무로 예측하기

• sample() 함수를 이용하여 10개를 랜덤하게 추출
• predict(r, newdata=…) newdata에는 데이터프레임으로 4개의 변수만.
• predict()는 확률로 표시
• predict(r, newdata=…, type=‘class’)옵션을 추가하여 가장 높은 확률의 class로 예측
• table()로 확인해보면 1개의 오분류가 있음.
• 샘플 10개가 추출될 때마다 결과가 다를 수 있음

기계 학습에서는 어떻게 활용하나?

데이터를 훈련데이터(training)와 테스트 데이터(testing)으로 분류 훈련데이터로 군집분류 규칙을 찾고, 테스트데이터로 정확도 확인 패키지: caret(Classification And REgression Training) createDataPartition(데이터, p=비율) 사용

📌 데이터 파티션 – 훈련 & 테스트

• iris 데이터 중 70%를 훈련 데이터(training)로
• 30%를 테스트 데이터(testing)로

의사결정 나무 규칙 구하기

• 훈련 데이터(training)를 이용하여 분류 규칙 찾기
• 변수 1~4까지 모두 사용
• 분류 규칙에는 Patal.Length와 Petal.Width 2개만으로

테스트 데이터로 확인

• 규칙 r로 예측한 결과를 testing의 새로운 변수 predict로 저장
• table로 예측의 정확도 확인
• testing$Species는 원래 종, testing$predict는 규칙에 의한 분류
• 1개가 오분류됨

🎯 정확도 확인

• 정확도는 95.56%

워드 클라우드

• KoNLP 한국어 형태소 분석 패키지 CRAN에서 제외되어 수동 설치
• wordcloud 패키지 워드클라드를 그려주는 패키지
• 설치시 마다 매우 많은 시행 착오.
• 2024년에는 서버실 학생들이 cslab 서버에 설치함.

KoNLP 설치

출처: https://e-datanews.tistory.com/155

jdk 설치

install.packages("multilinguer") library(multilinguer) install_jdk()

KoNLP 설치

install.packages("remotes") remotes::install_github("haven-jeon/KoNLP", force = T, upgrade = "never", INSTALL_opts = c("--no-multiarch"))

샘플 코드

library(KoNLP) extractNoun("KoNLP 설치 정말 어렵네요!")

📌CM/QA

CM Configuration Management

• 정의 및 목적
• 핵심 활동
• 변경 관리 프로세스
• 버전관리와 릴리스

  QA Quality Assurance

• 정의 및 목적
• 핵심 활동

  RTM - Requirement Traceability Matrix

📌 CM - 정의 및 목적

• CM의 정의 소프트웨어 시스템의 모든 구성요소를 체계적으로 정의하고, 관리하고, 변경을 기록항, 개발과정의 일관성을 보장하는 활동
• CM의 목적 변경 사항 추적 재현 가능성 유지 효율적인 협업 환경 조성

📌 CM - 핵심 활동

• 식별(Idenification) 모든 산출물(코드, 문서, 요구사항 등)고유하게 식별 식별 체계 예 : 버전 번호 체계 (1.0.0, 1.1.0 등)

• 통제(Control) 변경 요청을 관리하고 승인된 변경만 반영 변경 요청 프로세스

  변경 요청 생성 -> 영향 분석 -> 승인/거부 -> 적용

• 상태기록(Status Accounting) 모든 구성요소의 현재 상태를 기록하고 유지 예 : "모듈 A는 1.2 버전이며, 테스트 상태 완료

• 검증(Auditing) CM 프로세스가 올바르게 실행되었는지 확인 예 : 특정 구성요소가 올바른 버전으로 배포되었는지 검증

CM - 변경관리 프로세스

• 변경 요청 생성단계 모든 변경 요청은 기록으로 관리 문서화 내용 : 변경의 이유, 영향, 대안, 예상 결과
• 변경 승인 단계 변경관리위원회(Change Control Board)와 같은 검토 단위 구성
• 적용 및 검증 단계 변경 후 반드시 검증 테스트를 수행

CM - 버전관리와 릴리스

- 버전 관리의 기본 원칙

버전 번호 체계

• 메이저(주요 변경), 마이너(기능 추가), 패치(버그 수정)의 구분
  • 분리된 환경 유지
• 개발 환겨, 테스트 환경, 운영 환경 분리
  • 롤백 전략
• "이전 상태로 되돌릴 수 있는 시스템" 설계해야함

- 릴리스 관리

• 릴리스 계획 수립
  • 주요 기능, 품질 목표, 일정에 따른 릴리스 로드맵 작성
• 변경 사항 요약
  • 모든 릴리스마ㅏ 변경 사항과 새로운 위혐 요소 문서화

📌 QA - 정의 및 목적

• 정의 품질을 보장하기 위한 계획적이고 체계적인 활동
• 목적 결함 없는 소프트웨어를 제공하며, 고객의 요구를 충족시키는 것

📌 QA - 핵심 활동

• 프로젝트 정의 및 개선 개발 표준, 코드 리뷰 규칙, 테스트 전략 정의
• 예방 줌심 활동 테스트 설계와 요구사항 문석으로 초기 결함 예방
• 품질 매트릭스 관리 결함 밀도, 테스트 커버리지, 평균 수명 시간 측정

💻 핵심 활동 사례 - 테스트전략 설계

• 테스트 계획 작성 무엇을 테스트할 것인가? (테스트 대상 정의) 테스트 범위 : 기능 테스트, 비기능 테스트(성능, 보안 등) 우선순위 결정 : 위험도에 따라 테스트 순위 지정
• 테스트 실행 기준 테스트 시작/종료 기준
  • 시작 : 개발 80% 이상 완료, 테스트 환경 준비 완료 상태
  • 종료 : 주요 결함 수정 완료, 요구사항 충족률 95% 이상 상태

    테스트케이스 설계

  • 테스트 시나리오 사용자의 실제 동작을 기반으로 설계 예 : 사용자가 로그인 후, 비밀번호를 변경할 떄의 모든 경로 테스트
• 경계값 분석 입려값의 최속밧, 최대값, 중간값 테스트 예 : 입력 필드에 "최대 100자 허용" 이면 99, 100, 101자를 테스트

QA평가 및 보고

• 결함 보고서 작성 결함 설명, 재현 절차, 기대 결과, 실제 결과
• 품질 목표와 성과 평가 목표 : 결함 밀도 >= 0.5개/1000라인, 테스트 커버리지 >= 90%

📌 QA – CM과 QA의 관계

CM과 QA의 관계

• 변경 사항이 품질에 미치는 영향 추적
  • QA 활동에서 발견된 결함 → CM 기록에 반영
• CM과 QA의 협력
  • QA는 변경 요청 단계에서 잠재적 품질 문제를 검토

품질 보장을 위한 통합된 프로세스

• 변경 요청 → 영향 분석(QA 참여) → 구현 및 검증
• CM과 QA 협력

📌 RTM – Requirement Traceability Matrix

정의

• 고객 요구사항부터 설계, 개발, 테스트에 이르기까지 추적 가능한 매트릭스를 구축
  → 프로젝트의 품질 보증과 요구사항 충족을 보장하는 핵심 활동
• RTM은 SDLC 각 단계에서 요구사항이 제대로 반영되고 테스트되었는지 확인할 수 있는 기능 제공

RTM – 구성 요소

• 요구사항 ID: 요구사항을 고유하게 식별하는 ID
• 고객 요구사항: 고객이 요청한 주요 기능 또는 성능 목표
• 기능적 요구사항: 고객 요구 구현 위한 시스템 요구사항
• 설계 요소: 요구사항을 반영한 설계 단계의 산출물
• 테스트 케이스 ID: 요구사항 검증하는 테스트 케이스 식별자
• 상태(Status): 요구사항 충족 여부

💻 RTM – 예시

Sofrware Quality -> 얼마나 요구사항을 충족 시켰나?

🎯 체크섬(계산하는법) 한번 더 확인(과제 진행)

📌 IP프로토콜

• IP 프로토콜의 주요 특징 비연결형 서비스를 제공 패킷을 분할/병합하는 기능을 수행 데이터 체크섬은 제공하지 않고, 헤더 체크섬만 제공 Best Effort 원칙에 따른 전송 기능을 제공

📌 IP 헤더 구조

• IP 프로토콜에서 정의된 패킷의 IP 헤더의 구조(상단의 숫자는 비트 수)

DS/ECN

DS와 ECN 필드가 도입되기 전에는 8비트의 Service Type(DS+ECN) 필드로 정의되어 우선순위, 지연, 전송률, 신뢰성 등의 값을 지정할 수 있었음 Service Type 필드는 IP 프로토콜이 사용자에게 제공하는 서비스의 품질에 관련된 내용을 표현 각 비트 값의 의미는 [표 7-4]와 같음

혼잡 제어를 위한 ECN 필드 값의 의미는 [표 7-5]와 같음

DS 코드포인트라고도 하는 DS 필드 값은 차등 서비스의 기준이 되는 레이블 값으로 64개의 트래픽 클래스를 정의 DS 서비스는 비교적 단순한 원리에 의하여 차등화된 서비스를 제공하지만 내부적인 처리 과정은 복잡한 구조에 의하여 이루어짐

📌 패킷 분할

IP 프로토콜은 상위 계층에서 내려온 전송 데이터가 패킷 하나로 전송하기에 너무 크면 분할해 전송하는 기능을 제공

• 패킷 분할과 관련된 필드

1. Identification(식별자 혹은 구분자)
2. DF(Don’t Fragment)
3. MF(More Fragment)
4. Fragment Offset(분할 옵셋)

1. dentification(식별자 혹은 구분자) : IP 헤더의 두 번째 워드에는 패킷 분할과 관련된 정보가 포함

이 중 Identification 필드는 송신 호스트가 지정하는 패킷 구분자 기능을 수행 IP 프로토콜이 분할한 패킷들에 동일한 고유 번호를 부여함으로써, 수신 호스트가 Identification 번호가 같은 패킷을 다시 병합(Reassembly)할 수 있도록 해 줌 패킷을 분할하지 않으면 패킷을 전송할 때마다 이 필드의 값은 하나씩 증가

2. DF(Don’t Fragment) : 패킷이 분할되지 않도록 한다.

즉, 값을 1로 지정하면 패킷 분할을 막을 수 있음 수신 호스트가 분할되어 입력된 패킷들을 병합하는 기능이 없을 때 사용 따라서 중간 경우 네트워크에서는 자신이 처리 가능한 패킷의 크기보다 큰 IP 패킷에 DF 필드가 설정되어 있으면 분할 기능을 수행하지 않고 패킷을 버림

3. MF(More Fragment) : 분할된 패킷을 전송할 때는 여러 개의 분할 패킷이 연속해서 전송되므로 MF 필드 값을 1로 지정하여, 분할 패킷이 뒤에 계속됨을 표시해주어야 한다.

분할 패킷 중 마지막 패킷은 MF 비트를 0으로 지정하여 분할 패킷이 더 없음을 표시한다.

4. Fragment Offset(분할 옵셋) : 패킷 분할이 이루어지면 12비트의 Fragment Offset 필드를 사용한다.

저장되는 값은 분할된 패킷의 내용이 원래의 분할 전 데이터에서 위치하는 상대 주소 값이다. 값은 8비트의 배수이므로, Fragment Offset 값이 64라면 원래 데이터에서 64 × 8 = 512번째에 위치한다.

📌 주소 관련 필드

• Source Address는 송신 호스트의 IP 주소

• Destination Address는 수신 호스트의 IP 주소

• IP 주소 체계는 [그림 7-13]과 같이 크게 다섯 종류

• 클래스 A, B, C는 유니캐스팅에서 이용하고, 클래스 D는 멀티캐스팅에서 이용

• 클래스 E는 향후 새로운 응용 환경을 위하여 잠정적으로 예약된 클래스

• 클래스 A, B, C는 주소를 network와 host 필드로 구분해 관리함으로써, 클래스별로 네트워크 크기에 따라 주소 관리를 다르게 함

  ---

  [표 7-6]과 같은 IP 주소 값의 정보만으로 이 주소가 속한 클래스를 알 수 있음

• network(네트워크): 네트워크 주소 전 세계적으로 유일한 번호가 모든 컴퓨터 네트워크에 할당 현재 이 주소의 할당은 NIC(Network Information Center)에서 담당

• host(호스트): 네트워크 주소가 결정되면 하위의 호스트 주소를 의미하는 host 비트 값을 개별 네트워크의 관리자가 할당 클래스 A는 host 비트의 크기가 크기 때문에 규모가 큰 네트워크에서 사용하고, 클래스 C는 규모가 작은 네트워크에서 사용함

📌 기타 필드

• IP 프로토콜에서는 다음과 같은 다양한 필드를 정의
  • Version Number(버전 번호), Header Length(헤더 길이), Packet Length(패킷 길이)
  • Time To Live(생존 시간), Transport(전송 프로토콜), Header Checksum(헤더 체크섬), Options(옵션), P adding(패딩)

Version Number(버전 번호) :

현재 인터넷 환경에서 사용하는 IP 프로토콜은 버전 4 IP 프로토콜의 새로운 버전인 IPv6과 구분하기 위해 기존 IP 프로토콜을 IPv4로 표현

Header Length(헤더 길이) :

IP 프로토콜의 헤더 길이를 32비트 워드 단위로 표시 일반 패킷을 전송하는 경우에 헤더의 Options, Padding 필드가 빠지므로 IP 헤더의 최소 크기는 5

Packet Length(패킷 길이) :

IP 헤더를 포함하여 패킷의 전체 길이 필드의 크기가 16비트이므로 IP 프로토콜에서 지원하는 패킷의 최대 크기는 바이트 그러나 이는 이상적인 최댓값으로, IP 프로토콜에서 65,535바이트의 IP 패킷을 전송해도 대부분 데이터 링크 계층에서 분할해 전송 따라서 실제 환경에서 IP 프로토콜은 IP 패킷을 더 작은 단위로 만든다. IP 패킷의 크기는 일반적으로 8,192바이트를 넘지 않는다.

Time To Live(생존 기간) :

패킷 전송 과정에서 패킷이 올바른 목적지를 찾지 못하면 수신 호스트에 제대로 도착하지 않고, 네트워크 내부에서 떠돈다. 이런 현상을 방지하려고 Time To Live 필드를 사용한다. 송신 호스트가 패킷을 전송하기 전에 네트워크에서 생존할 수 있는 시간을 지정하고, 각 라우터에서는 패킷이 지나갈 때마다 이 필드 값을 감소시키면서 패킷을 중개한다. 임의의 라우터에서 Time To Live 값이 0으로 감소하면 패킷은 자동으로 버려지고, 패킷 송신 호스트에 ICMP 오류 메시지가 전달된다.

Transport(전송 프로토콜) :

[그림 7-14]와 같이 IP 프로토콜에 데이터 전송을 요구한 전송 계층의 프로토콜을 가리킨다. 전송 계층의 TCP 세그먼트와 UDP 데이터그램, 네트워크 계층의 ICMP 패킷은 모두 IP 패킷의 데이터를 의미하는 페이로드(Payload) 부분에 캡슐화되어 전송된다. 왼쪽의 숫자는 Transport 필드 값을 의미하며, TCP는 6, UDP는 17, ICMP는 1의 값이 저장된다. 따라서 패킷 수신자는 페이로드 내부에 어느 프로토콜 정보가 있는지 판단할 수 있다.

Head Checksum(헤더 체크섬) :

전송 과정에서 발생할 수 있는 헤더 오류를 검출하는 기능으로, 데이터 오류는 검출하지 않는다. 이와 달리 계층 4인 TCP, UDP 프로토콜의 헤더는 데이터와 헤더 모두에 대한 체크섬 정보를 제공하기 때문에 IP와 상호 보완적인 오류 검출 기능을 수행한다.

Options(옵션) :

네트워크 관리나 보안처럼 특수 용도로 이용할 수 있다.

Padding(패딩) :

IP 헤더의 크기는 32비트 워드의 크기가 배수가 되도록 설계되어 있다. 앞서 설명한 필드의 전체 크기가 이 조건에 맞지 않으면 이 필드를 사용해 조정할 수 있다.

📌 분할의 필요성

• 다양한 유형의 네트워크를 통해 패킷을 중개하려면, IP 프로토콜이 패킷을 각 네트워크에서 처리하기 편한 크기로 분할(Fragmentation)해야 함

• 상위 계층에서 더 큰 데이터 전송을 요구하면 IP 프로토콜에서 패킷 분할 과정을 먼저 수행해 전송

• 맨 밑에 위치한 데이터 링크 계층(계층 2) 프로토콜의 프레임은 크기가 프로토콜마다 다름

• 상위 계층에서 내려온 데이터를 계층 2의 프레임 틀에 담을 수 있도록 IP 프로토콜에서 분할 과정을 거친 후에 전송

• 수신 호스트에서는 이를 다시 합치는 병합 작업을 수행

[그림 7-16]은 IP 프로토콜의 패킷 분할 과정의 예

• IP 헤더를 제외한 전송 데이터의 크기는 380바이트, 패킷은 최대 크기가 128바이트 가정

• 먼저 8의 배수로 정의된 Fragment Offset 필드를 계산, 이 값에 8을 곱한 크기가 분할 전의 데이터 위치
• 패킷 전체의 최대 크기인 128바이트에서 헤더인 20바이트를 빼면 108바이트 분할 패킷에 보관할 수 있는 데이터의 최대 크기는 (108을 8로 나눈 몫(정수 값)) x 8=104바이트 분할된 패킷의 개수는 4개(=380을 104로 나눈 몫+1) 각 패킷의 Fragment Offset 필드 값은 0, 13, 26, 39

분할 패킷인 분할 1, 분할 2, 분할 3은 데이터 크기 104바이트에 헤더 크기 20바이트를 더해 124 패킷의 전체 크기 Packet Length=124바이트

• 마지막 분할 패킷은 전체 데이터의 크기 380에서 3개의 분할 패킷 크기 3 x 104를 빼면 68바이트 이 값에 헤더 크기인 20바이트를 더해 Packet Length = 88바이트

분할한 패킷의 Identification 필드에는 동일한 번호를 부여 그림에서는 임의로 1254번을 가정 MF 필드는 마지막 패킷을 제외하고 1을 지정해 분할 패킷이 이어지고 있음을 표시

ggplot2

• ggplot()함수는 앞에서 설명한 고수준, 저수준 작도를 편리하게 사용할 수 있도록 개발된 패키지

• Advantages of ggplot2 consistent underlying grammar of graphics (Wilkinson, 2005) plot specification at a high level of abstraction very flexible theme system for polishing plot appearance mature and complete graphics system many users, active mailing list

가본 syntax

library(ggplot2) ggplot(df, aes(x=x축 데이터, y=y축 데이터)) + geom_함수

• In ggplot land aesthetic means "something you can see".
  • geom_함수 geom_bar() geom_line() geom_point() geom_histogram() labs() facet_wrap()

Ex

data <- read.csv("../mydata/경기도 화성시_관광통계_20231025.csv",fileEncoding="CP949")

data

# ggplot 객체 생성
p <- ggplot(data, aes(x = 번호, y = 공룡알화석산지))

# 점 추가
p <- p + geom_point(fill = 'red', color = 'blue', shape = 21, size = 4)

# 최종 플롯 출력
p + geom_line(color='blue', linetype=2)

📌 막대그래프- 빈도수를 높이로

• aes(변수 1개) cyl은 숫자변수로 연속형 - factor()로 범주형으로 변환
• 기본 barplot에서는 table()의 결과가 있었어야 함.
• fill은 내부 색상
• color는 테두리
• width는 막대의 너비
• linewidth는 선 두께

• fill=범주형: 범주형 자료의 값에 따라 다른 색상 – - - aes 안에서 지정
• table(x, y)의 결과 필요 없음.
• coord_flip() 좌표축 회전
• 다른 그래프에서 적용 가능
• position=‘dodge’ 사용

```py
p <- ggplot(mtcars, aes(factor(cyl), fill=factor(gear)))
p + geom_bar()

p <- ggplot(mtcars, aes(factor(cyl), fill=factor(gear)))
p <- p + geom_bar()
p + coord_flip()

p <- ggplot(mtcars, aes(factor(cyl), fill=factor(gear)))
p <- p + geom_bar(position = 'dodge')
p

📌 막대그래프 - 평균을 높이로, 수직누적 막대그래프- 두 그룹별 평균

• 그룹별 평균을 구할 때 tapply보다는 summaryBy를 이용(데이터프레임 필요)
• aes(변수 1개)
• 막대그래프의 y축은 기본적으로 주어진 변수의 count(빈도수)
• 예제처럼 cyl에 따른 mpg의 평균을 높이로 지정할 때는 두 변수를 모두 지정하고, 옵션stat=‘identity’ 지정
• 데이터 mtcars에서 두 변수 cyl과 gear의 각 그룹별 평균 구하기
• geom_bar()
• stat=‘identity’ 옵션 사용

library(doBy)
tbl <- summaryBy(mpg ~ cyl, data=mtcars, FUN=mean)
tbl

p <- ggplot(tbl, aes(factor(cyl), mpg.mean))
p + geom_bar(stat='identity', fill='gold', color='red')

library(doBy)
tbl <- summaryBy(mpg ~ cyl+gear, data=mtcars, FUN=mean)
tbl

p <- ggplot(tbl, aes(factor(cyl), mpg.mean, fill=factor(gear)))
p + geom_bar(stat='identity')

수평누적 막대그래프

-데이터 mtcars에서 두 변수 cyl과 gear의 각 그룹별 평균 구하기

• geom_col() 사용
• position=‘dodge’ 옵션 사용

📌 시계열 그래프_ geom_line()

꺽은선 그래프 – no 옵션

• aes(x, y) 순서로
• geom_line(): 선추가
• geom_point(): 점추가
• color는 색상
• shape: 점모양
• size: 점 크기
• linetype: 선모양
• linewidth:선 굵기

점모양

shape = 번호 (plot에서는 pch)

선 모양: plot에서는 lty, ggplot에서는 linetype

인 수	설명
linetype=0	투명선
linetype=1	실선
linetype=2	대시선
linetype=3	점선
linetype=4	점선과 대시선
linetype=5	긴 대시선
linetype=6	2개의 대시선

💻 Ex_여러 그래프를 한 화면에

# 데이터준비
library(dplyr)

data <- read.csv("../mydata/도로교통공단_시군구별 월별 교통사고 통계_20231231.csv",
                 fileEncoding="CP949")

chungju <- filter(data, 시군구=="충주시")
cheongju <- filter(data, 시군구=="청주시")
jecheon <- filter(data, 시군구=="제천시")

chungju

p <- ggplot()
p <- p + geom_line(data= chungju, aes(발생월, 사고건수), color='red') + 
    geom_point(data=chungju, aes(발생월, 사고건수), color='red')
p

💻 EX_그룹 변수로 그래프 나누어 그리기

# 데이터 준비
library(dplyr)

cb <- data %>%
    filter(시도=='충북') %>%
    filter(grepl('시$', 시군구)) %>%
    select(발생월, 시군구, 사고건수)

head(cb)

table(cb$`시군구`)

# 1번쨰 그림
library(dplyr)

cb <- data %>%
    filter(시도=='충북') %>%
    filter(grepl('시$', 시군구)) %>%
    select(발생월, 시군구, 사고건수)

head(cb)

table(cb$`시군구`)

p <- ggplot(cb, aes(발생월, 사고건수,
    color=시군구, shape=시군구, linetype=시군구))
p + geom_point() + geom_line()

# 2번째 그림
gang <- data %>%
    filter(시도=='서울') %>%
    filter(grepl('^강', 시군구)) %>%
    select(발생월, 시군구, 사고건수)

head(cb)
p <- ggplot(gang, aes(발생월, 사고건수,
    color=시군구, shape=시군구, linetype=시군구))
p + geom_point() + geom_line()

📌 산점도 그리기- geom_point()

데이터 mtcars- 기본 작도

• wt는 차의 무게
• mpg는 연비
• cyl는 실린더의 개수(연속형을 범주형으로 변환)
• pch는 점의 모양
• cex는 점의 크기
• ggplot()으로 그림 준비
• geom_point()로 점 그리기
• color: 색상
• size: 크기
• shape: 점의 모양
• 변수의 값에 따라 지정하려면 aes() 안에

📌 회의

우리는 항상 화요일 4:30분부터 6:30분까지 학교 도서관에 있는 PBL룸을 빌려 회의를 진행했다. (HDMI케이블이 있어서 노트북과 연결해서 진행사항을 함께 보기도 수훨했고 칠판과 펜도 있어서 서로의 의견을 눈으로 직접 보기에도 좋았다) 우리는 한번 갈아 엎었고 .. 기본 index 페이지에서도 각자 맡아서 해온 결과물이 생각보다 좋지 않아서 어제인 11/29 한 결과까지만 하고 포기하기로했다. (시험기간에 다른 전공 프로젝트에 팀원들이 바쁘다고 하여.. 결정된것) 시작할 당시에는 약 1달하고 10일정도에 기간이 있어서 넉넉하게 잡고 천천히 준비했던거 같은데.. 정말 안타까운 마음밖에 없다. 혼자 했던 코드들을 들고 내가 한다고 해도 제출기간안에 끝낼 수 있다는 자신도 없어...포기를 했다. 정말 ...눈물이 나네

📌 실패요인 (나의 생각)

1. 우리는 각자 해올일을 분담해서 섹션별로 개발을 진행하고 오류또는 디자인에 만족감을 얻을 때 까지 고치고 다시 고치고 반복하다 보니 처음에 생각했던 디자인과 후에 만들어진 결과가 너무 다른점이였다. 시간이 많았을 당시 이것도 해보고 저것도 해보고 마음에 안드니 다시하고를 반복하다보니 정확한 뼈대를 잡지 못하고 개발부터 들어가게 된것이 문제라고 생각한다.

2. 서로의 일정이 바빠 만나기 힘들다는점이다. 우리는 같은학교에 같은학년으로 수업을 듣고있지만 전공수업이 겹치는건 1개뿐이고 나머지 방과후 시간은 각자 할일이 있어 만나는것에 있어서 자유롭지 못했다. 또한 주말동안 본가를 자주 가게되어 이곳에 집중하지 않고 바쁜 팀원 + 학생회 활동과 잡힌 약속이 있어 급하게 프로젝트를 끝내보려고 밤을 새워서 한 나의 잘못이다. 이것저것 파일정리도 안하고 진행하다보니까 오류를 잡았던 코드들도 어딘가에 사라져있었고 주석처리나 코드를 분류를 안하고 하다보니 눈도 아플지경이였다. 매우 아쉽다... 아쉬워

3. 공유를 하지 않는점과 개인의 능력차가 컸다고 생각한다. 한사람이 자신이 맡은바를 다해오고 오면 다른 사람은 우리가 회의때 생각한 디자인과 다르게해서 다시 그쪽을 봐주고 또 하다보니 그사람과 생각이 달라서 서로 다른 결과물을 만들다 보니 어질어질했다. 깃허브에 서로 관리를 했더라면 좀더 나았을까 싶다.. (팀원에 실력차이는 당연히 있고 그점은 잘못되었다고 생각하지 않는다.)

4. 마음가짐이다. 이 공모전을 시작하자고 했을때 모두는 공모전에 참여하여 이것저것 배우고 함께 하나의 프로젝트를 만들다보니 좋은 결과물이 나왔으면 좋겠다라고 생각했다. 하지만 공모전에 참여만으로는 나는 원하지 않았다. 열심히 한만큼, 하면서 배운만큼에 노력이 증명되는 것을 원했다. (입상하는것) 팀원들은 공모전에 참가에 의의를 뒀지만 결국에 결과물에 쫓겨서 하다보니 서로가 배운점이 없었다고 얘기한것이 매우 아쉬었다. 마음가짐을 좀만 달리해서 더 노력하고 핸드폰, 술먹는 시간을 줄였다면 더 나은 지금이 되었을텐데 말이다.

📌 배운점

1. DB를 mysqlworkbench만 사용한 경험이 있엇다. 컴퓨터로컬에서 작업을 주로 하다보니 밖에 나가 함께 프로젝트에 진행도를 보여줄때 원격으로 집에있는 컴퓨터와 연결해 보여주곤했다. 이번에 아마존 RDS를 사용해서 내가 사용한 mysql과 버전을 맞춰 생성한 엔드포인트를 DBeaver 연결시켜서 사용했다. 그래서 나의 servername네임 값과 비밀번호를 안다면 누구나 바로 사용이 가능하다는점에서 아주아주...편리한 지식을 하나 쌓았다.

연결 참고자료

2. 나는 https://www.netlify.com/를 이용해서 내 도메인을 관리하고 설정했었다. 하지만 netlify는 php를 지원하지 않아.. (다른 언어 쓸껄... 다음에는 다른걸로 해야지) 아마존에 있는 Elastic Beanstalk를 사용해서 배포하기로 했다. 프리티어로 설정하는 부분에서 여러가지도 사용해보고 아마존에 많이 지원해주는 기능이 많아서 아마존을 자주 사용하면 좋을거 같다.

   참고자료 : https://docs.aws.amazon.com/ko_kr/elasticbeanstalk/latest/dg/GettingStarted.html

3. 공공데이터를 이용하는데에 좀더 익숙해지는거같다. csv파일을 받아서 나의 입맛대로 바꾸는점이 나에게 흥미를 불러오고 이부분에서 더 집중하고 재밌게 한거같았다. 여러 페이지들도 보고 여러시도도 해볼 수 있다는 점이 그래도 공모전을 준비하면서 좋은점도 있다고 생각이 드는 부분이다.

   Fullpagejs 챗봇 플라스크 장고

+ 다른이야기

저번에 교통대학교에서 지원해준 adsp자격증 합격을 했다.. 운좋게도.. 강의 하루보고 2일정도 기출문제만 돌리고 개념외우고 한거같은데 운이 좋았던거 같다. (생각보다 전공내용에서도 겹치는 부분이 많았다) 다음기회에는 정보처리기사, 빅데이터분석기사 도전할 시간이 있으면 해보자

Tasks

• 1. 기본 탐색 데이터 분석
• 2. 연구 질문에 대한 데이터 분석
• 3. 데이터 정리(전처리)
• 4. 프로토타입 모델(시험 모델링)
• 5. 시각화

8 Best Data Visualization Tools and Libraries to Learn in 2022

• 1. Tableau
• 2. Microsoft Power BI
• 3. QlikView
• 4. QlikSense
• 5. Excel
• 6. Matplotlib - Python
• 7. ggplot2 - R
• 8. D3.js - Javascript

📌 기본적인 그래프 함수

• barplot(범주형) 막대그래프
• pie(범주형) 원그래프
• hist(연속형) 히스토그램
• boxplot(연속형) 상자그림
• plot() 기본적으로는 산점도 자료의 형태에 따라 유동적

📌 막대그래프 - barplot()

barplot()

• cyl의 빈도표(table)을 구하고, 이를 막대그래프로

• col은 사각형 색상 지정

• border는 테두리 색상 지정

• 그룹 별로 다른 색상 지정 가능

• col=c( , , )

📌 수직, 수평 누적 막대그래프

• 변수 cyl의 각 값에 대하여 gear의 비율만큼 다른 색상으로

• table(변수1, 변수2)와 같이 2차원 교차표를 생성하여 막대그래프

• 변수 cyl의 각 값에 대하여 gear의 비율만큼 다른 색상으로

• beside=T 옵션으로 수평으로

📌 가공된 데이터 막대그래프 그리기

-1차 가공된 데이터를 입력할 때는 벡터로 입력

• names()로 그룹 이름 부여하고, 이를 막대그래프로

정리된 데이터 입력하기 – 2차원

• 2차원 데이터를 입력할 때는 행렬 형태로 입력

• 열이름 -> colnames

• 행이름 -> rownames

• 행렬로 입력된 데이터를 이용하여 수직누적 막대그래프를 그릴 수 있다.

• legend 추가 가능

• 행과 열 바꾸기

• t(matrix) 전치행렬(행과 열을 바꾸는 기능)

그룹별 평균을 높이로

• tapply()를 적용하여 각 그룹별 평균을 구하고
• 그 결과를 barplot()을 이용하여 그린다.

📌 원그래프 - pie()

pie() - 원그래프

• 색상은 난수로 생성

• pie(벡터, labels=표시내용)

• 벡터 pct는 비율(%) 계산

• label: 이름(비율%) 만들기

• 옵션 labels 이용

그룹별 합계를 높이로

• csv 파일의 인코딩 주의

• tapply()를 적용하여 각 그룹별 합계를 구하고

• 그 결과를 barplot()을 이용하여 그린다.

• tapply()를 적용하여 각 그룹별 평균을 구하고

• 그 결과를 barplot()을 이용하여 그린다.

• paste0를 이용하여 가로축의 이름 변경

data <- read.csv("../mydata/도로교통공단_시군구별 월별 교통사고 통계_20231231.csv", fileEncoding = "CP949")
head(data)

📌 히스토그램 - hist()

hist(연속형)- 디폴트

• 자동으로 계급 설정

• breaks로 계급 직접 입력 가능

📌 상자그림 - boxplot()

boxplot(연속형)

• 아래/위는 최솟값/ 최댓값을 나타낸다.

• 상자의 가운데 굵은 선은 중앙값(median)

• 상자의 아래/위는 사분위수의 Q1과 Q3를 나타낸다.

boxplot(연속형 ~ 범주형)

• cyl의 값에 따라 3그룹으로 분리하고, 각 그룹의 상자그림을 그린다.

• 색상을 1개만 지정하면 모두 같은 색

• 그룹별로 다르게 지정 가능

• 아래 동그라미는 이상점(outlier)

📌 산점도 - plot()

plot(x, y)

• x, y는 모두 연속형 자료
• 데이터 cars
• speed: 속력
• dist: 제동거리
• x, y 순서로 인식

data <- read.csv("../mydata/도로교통공단_시군구별 월별 교통사고 통계_20231231.csv", fileEncoding = "CP949")
jongro <- subset(data, 시군구 =='종로구')
jongro

시계열 그래프

• plot(시간, 연속형)
• type=‘o’에서 ‘o'는 소문자 오(o)

📌 그래프 옵션

📌 (1) 그래프 옵션 – 제목/축

데이터 cars: speed vs dist

• 데이터 cars는 속력(speed)에 따른 제동 거리(dist)
• 기본 그래프
• main=전체 그래프의 제목

제목붙이기

• xlab=x축 제목
• ylab=y축 제목

## x, y축의 범위
- x축의 범위는xlim=c(start, end)
- y축의 범위는ylim=c(start, end)

x, y 축의 눈금

• x, y축 눈금은 별도의 명령어 axis() 사용
• side=1: 아래쪽
• side=2: 왼쪽
• at: 표시할 위치
• labels: 표시할 내용

축지우기

• axes=F으로 축표시 제거

📌 (2) 그래프 옵션 - 그래프타입

📌 (3) 그래프 옵션 - 색/선//기호

📌 (3-2) 그래프 옵션 - 점 모양

pch = 번호