* 발표회 전날 메타버스를 사전 탐방했다. 생각보다 캐릭터를 다양하게 꾸밀 수 있어서, 꾸미는 재미가 나름 있었다.
* 발표회 전날 메타버스 사전 탐방 시간이 꽤 길었는데, 이때 다른 팀들 부스를 꽤 돌았다.
* 메타버스 발표회 당일, 팀원들과 시간을 나눠서 부스를 지켰다. 최소한 한 명은 지켜야 하지만,
팀원들 모두 지쳤는지 대부분 우리 부스 안에 있었다 ㅎ
* 사실 많은 분들이 오실 줄 알았는데, 코치님과 매니저님, 그리고 운영진분들이 다였다! 질문이 많이 올까 봐 나름 걱정했는데, 다들 발표 자료 보고, 발표 영상 보는 게 다였다!
* 각 부스의 입구에 포스터가 있고, 부스에는 발표 영상과 발표 자료, 그리고 후기를 남길 수 있는 패들렛이 존재하였다. 나는 보통 다른 조들의 발표 자료를 보고, 발표 영상 중에 시연 영상 부분만 봤다. 아마 다른 분들도 그랬지 않을까 생각해 본다.
* 많은 분들이 패들렛에 좋은 후기와 추가 보완했으면 하는 점들을 적어주셨다.

* 조원들이랑 부스 지키는 시간을 정해뒀다. 내 시간이 아닐 때에는 다른 부스도 돌아다니며 발표 자료를 감상했다.
* 매니저님이랑 코치님이랑 5, 6반 다 같이 하트도 그렸다!! 하트 만들기 얼마나 힘들던지...
* 모두 다양하게 옷을 입는다. 각자의 개성이 드러나는 캐릭터가 아니었을까 생각한다.

이벤트

• 메타버스를 돌아다니면서 14개의 보물 상자를 모두 모아 문장을 완성하는 이벤트다.
• 사실 이전 기수분들의 블로그를 봐서 정답을 알고 있었다. 하지만 진짜로 그 문장일까 생각했지만, 똑같았다 ㅎㅎ 5기 때는 바꾸셔야 할 거 같습니다!
• 빅프로젝트 정말 수고많았어요!

회고

• 어떤 서비스를 만들건지 기획부터 시작해서, 개발까지. 처음부터 끝까지 팀원들과 하나하나 상의하면서 프로젝트를 잘 마무리 할 수 있었다.
• 저번 기수(3기)가 그 이전 기수(2기)보다 한 주 정도 빅 프로젝트 기간이 짧았다고 들었다. 하지만 이번 기수(4기) 또한 이전 기수(3기)보다 한 주 더 짧아졌다. 이 부분이 매우 아쉬웠다. 프로젝트 주제를 정하고 기획하는데 생각보다 많은 시간이 들어갔다. 나를 제외한 다른 조들도! 기간이 짧아진 만큼, 개발 기간이 짧아지다 보니까, 시간에 쫓기기도 하고, 더 구현하고 싶은 기능들을 구현하지 못한 부분이 아쉬웠다.
• 물론 내가 잘 못하는 것도 맞다! 나에게는 첫 웹 프로젝트였다. 여기에 우리 팀원들 모두 백엔드, 프런트엔드가 처음이었다! 그래서인지, 다른 조의 경우 웹 프로젝트를 해본 경험이 있는 분들의 경우, 우리보다 더 수월하게 프로젝트를 진행해 나가긴 했다. 하지만 우리 팀원들 정말 최선을 다했고, 그걸 모두 알기 때문에 후회는 없다! 이 기회로 나 또한 많이 성장했다고 생각한다!
• 웹 프로젝트를 진행해 본 경험이 있는지, 프론트, 백, AI 등 어떤 역할을 담당하고 싶은지 등의 설문을 받고 조를 구성해 주는 것도 하나의 좋은 방법이라고 생각된다.
• 프로젝트 주제를 정하고 기획하는 단계가 많이 어려웠다. 그리고 마지막 발표를 내가 담당해서, 발표문을 작성하고 발표 영상을 찍었다. 근데, 이런 부분을 DX랑 하면 어떨까?라는 생각을 했다. DX가 기획하고 AI 팀에서 개발하는 것도 괜찮지 않나? 그랬다면, 개발에 더 집중하고 더 많은 기능, 더 좋은 기능을 구현할 수 있지 않았을까 하는 생각이 든다!
• 이러나저러나! 이번 빅프로젝트를 통해 나 또한 한 발짝 더 성장했다고 생각한다! 리액트가 처음이었지만, 또 도전하니 안 되는 것은 없구나!라는 걸 느꼈다. 몇 주 동안 매일 구글링하고 공부하고 시도해 봤다. 잘 모를 때는 주변 친구들에게 도움 요청해서 배웠다. 때로는 힘들었지만, 끝나고 나니 엄청 뿌듯하다! 모두 정말 수고하셨습니다. 좋은 결과 있기를 바라요!

15조에서 개발한 "회의 보조 서비스 플랫폼"에 대해 소개해드리려고 합니다. 이 서비스는 회의의 목적을 명확히 하고, 효율적으로 진행할 수 있는 도구를 제공하여 불필요한 회의를 줄이고, 직원들과 기업의 업무 효율성을 향상시키는 데 중점을 두었습니다.

서비스 기획 배경

“회의 왜 하는지…” 직장인들 불만 이유 1위는

1. 다양한 종류의 회의가 팀 협업에 중요한 역할을 하는데, 최근 조사에서 69%의 참가자가 불만족스러운 회의 경험을 한다는 결과가 도출됨.
2. 불만족의 주요 이유는 결론 부재와 목적 부재.
3. 불필요한 회의는 업무 효율성 감소와 직원 스트레스 증가로 이어짐.
4. 기업 입장에서는 불필요한 회의를 줄이고 업무 효율성을 높이기 위한 회의 문화 개선 필요.

주요 기능

1. 실시간 음성인식(STT) 기술을 활용하여 중요한 키워드 추출.
2. 추출된 키워드를 기반으로 실시간으로 뉴스 데이터 검색 및 요약 제공.
3. 회의 종료 후 맞춤 회의록 자동 생성.

서비스 차별점

• 네이버와 줌과의 비교에서 실시간 키워드 추출과 회의록 커스터마이징에서 차별화.
• 중요 키워드를 추출하고 실시간으로 해당 주제의 뉴스를 검색하여 참여자들에게 제공함.

서비스 플로우

• 회원가입을 통해 서비스 이용 가능.
• 로그인 후 가장 가까운 회의 일정 확인 및 관리.
• 회의 참여 페이지에서 실시간 STT를 통한 키워드 추출.
• 회의 종료 후 회의록을 통해 회의 내용 효율적으로 확인 가능.

AI 기술

• AI 기술은 STT, 키워드 추출, 키워드 설명, 회의 요약 네 가지로 구성.
• Google Cloud STT API와 GPT OpenAI API를 활용한 키워드 추출.
• KR-WordRank 모델을 사용하여 유의미한 키워드 추출.
• Naver Search API를 통해 키워드에 대한 뉴스 요약 제공.
• KoBART 모델과 OpenAI API를 활용한 회의 요약.

기대효과

B2C

• 개인 업무 효율성 증가: 서비스를 통해 낯선 용어에 신속하게 적응하며, 회의 내용을 정확히 이해할 수 있어 업무 효율성이 향상.
• 시간 및 비용 절감: 회의 참석자들은 회의에 소비되는 시간을 최소화하고, 목적을 명확하게 이해함으로써 시간과 비용을 절감.
• 자동 회의 기록 관리: 생성된 회의록을 활용하여 회의 내용을 간편하게 복습하고, 업무 계획을 세울 수 있음.
• 실시간 키워드 추출과 뉴스 요약: 회의 중에 실시간으로 키워드를 추출하고 최신 정보를 받아볼 수 있어 학습과 정보 습득이 용이.

B2B

• 기업 회의 문화 개선: 기업은 효율적인 회의 도구를 통해 불필요한 회의를 줄이고, 목적을 명확히 하여 회의 효율성을 향상.
• 팀 생산성 향상: 팀원들은 명확한 의사소통과 업무 목표 공유를 통해 팀 생산성이 향상되고, 효율적인 업무 프로세스를 유도.
• 자동화된 데이터 분석 및 리포트: 서비스는 회의 기록을 분석하여 기업에 중요한 인사이트를 제공하고, 통계 및 리포트를 통해 효과적인 의사결정을 지원.
• 다양한 팀 형태 지원: 서비스는 다양한 팀 구성과 업무 환경에 적응 가능하여 기업이 유연하게 서비스를 활용.

활용방안

• 인트라넷 시스템과의 통합으로 모든 회의 자료 효율적 관리.
• 업무 용어 사전을 활용하여 신입사원들의 빠른 업무 적응 지원.
• 학교에서는 수업과 관련된 키워드를 통해 실시간 정보 공유로 학습 향상.

기능 확장

• 다국어 지원 및 문화적 대응: 서비스를 국제적으로 확장하기 위해 다양한 언어를 지원
• 언어 감정 분석: 음성 분석을 통해 회의 참여자의 감정을 식별하고, 긍정적인 톤이나 부정적인 피드백을 탐지하여 효과적인 의사소통을 지원
• 회의 데이터 분석 및 통계: 회의 기록을 분석하여 회의의 품질, 참여도, 주요 토픽 등에 대한 통계를 제공

포스터

일정

1주차: 프로젝트 기획/설계

1주차에는 주제 정하기 바빴다.
1등 워크숍 때 정한 주제가 에이블에서 추구하는 프로젝트 방향성과 다르다는 피드백을 받았다.
B2C 관점 말고 B2B/B2G 관점으로 생각해보며 주제를 다시 한 번 생각해보라고 하셨다.

워크숍 때 생각했던 주제들 모두 엎고 팀원들 모두 다시 주제를 하나씩 더 생각해오기로 했다.

• 팀즈 프리미엄, 회의 요약 및 웹캠으로 사람을 분석해서 얼마나 집중했는지 등
• 가족 그림책 생성 서비스, 가족 구성원의 그림체로 그림 생성 후 그림책 생성
• 장례서비스 플랫폼, 장례 절차 추천 서비스 등
• 금융 교육 플랫폼, 증권 기사 요약 후 키워드 리스트 업 후 교육 진행 등
• KT 버전 에이닷, 통화 요약, 캘린더 일정 관리, 스팸 전화 등

이렇게 각자 의견을 내면, 어떤 의견이든 피드백을 통해 구체화시키며 한 주제에 대해 기능들을 잡아봤다. 이후, 각자 투표를 통해 어떤 주제가 가장 마음에 드는지 정했다. 그 결과, 팀즈 프리미엄과 금융 교육 플랫폼이 가장 많은 투표를 받았다.

두 주제 중 어떤 주제로 할 지 정하기 위해

각 주제에 대해

• 웹 페이지 구성
• 기능
• 데이터
• 주의점

등 구체화 하기 시작했다.

이렇게 구체화 하다보니, 두 주제를 합쳐보면 어떨까? 라는 의견이 나왔고, 전부 좋은 아이디어인 거 같다며 새롭게 의견들이 또 나왔다!

그 결과 우리 조의 주제는

New KT, New Keword Tool👍🏻

** 회의 보조 시스템**이다! 실시간으로 회의가 진행되고 있을 때, 회의 내용에서 핵심 키워드를 추출하고, 해당 키워드와 관련된 뉴스 기사를 요약 제공하는 서비스이다.

우리의 서비스에 대해서는 나중에 차차! 이야기하도록 하고!

회고

정말 빅프로젝트에서 주제 정하는 게 제일 힘들다더니 진짜인 거 같다. 일주일 내내 새로운 주제 어떤한 기능. 이것만 생각하고 계속 팀원들끼리 의견을 주고받았다. 마지막에는 다들 "이제 더 이상 내 머리에서 아이디어는 나오지 않아!"라고 외칠 정도로 ㅎㅎ 정말 모두가 최선을 다해 머리를 쥐어짜내며 주제를 정하였다.

코치님들도 주제가 가장 중요하니 시간이 더 걸리더라도 많은 이야기를 나눠보라고 하셨다. 정말 목 아픈 시간들이었지만, 내 머리에서도 이런 아이디어가 나올 수 있구나 싶은 시간들이었다. 그리고 나는 내가 처음부터 아이디어를 내는 것보단, 누군가에 아이디어에 아이디어를 더하는 게 더 잘하는 사람인 듯 하다.ㅎㅎㅎ

얼마 전 아이폰에서도 드디어! 통화 녹음이 된다는 것으로 이슈가 됐었다. 하지만 SKT 사용자만 가능했는데, 그 이유가 바로 '에이닷'이다.

따라서 내가 낸 아이디어 중 하나가 KT 버전 A-DOT(에이닷)이다. '나만의 개인 비서'라는 문구를 내세울 만큼, 에이닷은 사용자 맞춤형으로 다양한 정보를 제공한다. 통화 녹음 및 요약 기능을 제외하고도, 빅스비나 시리를 연상시키는 서비스도 제공한다.

나는 에이 닻을 보며 그럼 KT에는 없나?라는 생각을 했고, 'KT AI 통화 비서'를 발견했다. 하지만 보시다시피, KT AI 통화비서는 소상공인에게 제공되는 서비스로, 전화를 대신 받아주고 처리해 주는 AI 비서 서비스이다.

나는 이를 보고, 우리가 KT의 개인 통화 비서를 만들어보는 것이 어떨까!라는 생각을 했다!

내 주제는 채택되지는 않았지만, 나는 이번 주제를 정하기 위해 다양한 의견을 생각하고 찾아보면서, 내가 생각했던 아이디어는 역시 벌써 많이 나와있고, 더 많은 기능을 가지고 있음을 실감했다. 그와 동시에 놀라웠고 신기했다.

주제를 생각하면서, 창의성을 넘어서, 현재 기업들이 어떤 AI 서비스를 가지고 있고, 얼마큼 더 발전됐는지를 알 수 있었다. 특히 나는 KT에서 제공하는 서비스에 대해 많이 찾아봤다. 이번 기회를 통해 KT에서 어떤 서비스를 제공하는지, KT가 어떤 사업을 했는지 등 많은 것들을 알 수 있어서 참 좋았던 경험이기도 하다.

이제 진짜로 빅프로젝트 과정이 시작되었는데요, 그 첫번째 시작이 이번 1등 워크숍입니다! 이번 워크숍은 * 빅 프로젝트 팀원들과 친해지고, 빅프로젝트 과제를 하나로 선정 * 하는 시간을 가졌습니다!

팀원들 간에 이름 대신 영어 이름을 사용하기로 했는데, 생각나는 이름이 없어서 제가 좋아하는 윈터☃로 했습니다 ㅋㅋㅋㅋ
갑자기 5반의 윈터가 된 저...
그리고 팀원들이 페르소나 작업 중에 그려 준 저... 나름 닮은 거 같기도 하고 ㅎㅎ 다들 귀엽네요 ㅎㅎ

1등 워크숍을 진행하기 전에 각자 개인별 과제 정의서를 작성했었습니다. 각자 하고 싶은 주제와 선정 배경 및 기대효과 주요 서비스 내용 및 주요 기능 등을 적어왔고, 각자 팀원들이 적어온 개인별 과제 정의서를 읽어보고 하나의 주제로 정하고 그 주제를 확장해 나가는 방식이었습니다!

사실 주제를 확장하는 시간을 가지면서, 한 주제 3번은 엎은 거 같아요! 결국 그다음 날도 엎고 또 엎고... 주제 정하는 게 너무 힘들고 나중에는 머리가 더 이상 돌아가지 않아서 저희가 가진 주제를 다시 읽고 또 읽고 또 확장해나가다가 지금의 주제를 정하게 되었습니다! 어떤 주제인지는 차차...ㅎㅎ 밝혀보는 걸로 할게요.

제가 개인별 과제 정의 서애 적은 주제는 AI를 이용한 콜센터 지원 서비스였는데요. 고객의 음성을 통해 감점을 분석하고, 또 실시간 대화를 요약하고 흐름을 이해해서 답변도 추천해 주고 어떤 상담을 했는지 요약해 주는지 등등의 서비스를 생각했어요! 근데 위 사진이 KT의 AICC인데, 제가 생각한 모든 기능들이 벌써 전부다 너무 잘 되어있어서 ㅎㅎ 참.. 기술이라는 게 대단합니다.. 역시 내가 생각하면 다른 사람도 똑같이 생각하는 게 아이디어겠죠..

이렇게 1등 워크숍이 끝났고! 빅 프로젝트 잘 진행해서 좋은 결과를 얻을 수 있었으면 좋겠습니다.

🍚 밥집

✔️ 하성손칼국수

• 매주 화요일 휴무
• 11:00-20:00
• 경기 성남시 분당구 불정로77번길 4-4
• 민속칼국수 10,000
• 해물칼국수 10,000

1등 워크숍은 대면 필수여서 항상 그렇듯이, 여기 분당 KT 본사에 왔습니다 ㅎㅎ 마침 비가 엄청 많이 오는 날이어서, 비도 오니까 칼국수를 먹으러 가자! 해서 칼국수를 먹으러 오게 되었습니다. 하지만 8월부터 지금까지 먹으면서 거의 모든 집이 맛있었는데, 이 집은 어르신 들게 정말 인기 많은 집이더라고요? 하지만 저와 제 팀원들 입맛에는 맞지 않았습니다..😭 왜냐하면, 너무너무 짰습니다! 저는 민속 칼국수를 먹었는데, 칼국수가 이렇게 짤 수 있나 싶을 정도로 너무너무❗ 짰습니다❗ 오히려 제일 오른쪽 사진인 열무 비빔밥이 더 맛있었다는.. 혹시 이 집이 맛있었던 분들 계시다면 알려주세요.. 우리가 먹은 게 이상했었나... 싶을 정도로 짰거든요..

일정

코딩테스트 - 취업 컨설팅 특강 - 랜선 회식 순으로 진행되었다!

코딩테스트

벌써 마지막 3차 코딩 테스트.. 사실 코딩 테스트는 1, 2, 3차 가면 갈수록 점점 더 쉬워진 거 같아요! 제가 실력이 늘어서 그렇게 생각한 거라면 참 좋겠지만, 다른 분들도 다 그렇게 생각한다고 하셔서! 점점 더 쉬워진 게 맞는 거 같습니다 ㅎㅎ 사실 변명이라면 변명이지만, 근 며칠간 미니 프로젝트 + 졸업 논문 + 기말고사 때문에 쉴 틈 없이 바빠서, 코딩 테스트 준비를 또 거의 못했어요. 그래도 이전에 나름 열심히 준비했던 이유인지, 다행히도 이번 코딩 테스트는 다 맞았네요! 테스트 끝나자마자 점수가 나와서 얼마나 놀랐는지요..ㅎㅎ 앞으로 꾸준히 코딩 테스트 준비해서 앞으로도 좋은 결과가 있으면 좋겠습니다.

코딩 마스터스 시상

23.11.06. ~ 23.12.01. 약 4주 동안 2차 코딩 마스터스가 진행됐었습니다! 1차 코딩 마스터스 때 마스터로 끝내서, 이번에는 그랜드 마스터가 목표였고 코딩 마스터스가 시작한 초기에는 하루에 5문제씩 풀려고 노력했습니다! 하지만... 앞에서도 말한 변명? 과같이, 인생이 너무 힘들고 바쁜 관계로 이번에는 마스터도 못 찍었습니다😭😭 진짜 너무 제 자신한테 분하고 화가 나서 전날에 밤을 새더라도 마스터는 찍어야 하나 정말 고민 많이 했어요. 근데 이번 2차에는 기초 문제가 완전히 없고 초급부터 시작해서 중급 문제 수가 많아졌던 걸로 기억합니다. 그래서 그런지 마스터 찍기는 너무 어려울 듯하여 포기했습니다. 정말 제 자신한테 분하고 억울하고 화가 나는 이번 2차 코딩 마스터스였습니다. 다시 한번 시간 관리의 중요성, 계획의 중요성 등등을 깨닫는 하루입니다.

에이블 데이 선물

에이블 데이 1차 때는 텀블러!를 받았었는데, 이번에는 핸드크림과 여행용 파우치네요! 사실 저번 기수? 까지는 화장품을 줬던 걸로 기억해서 내심 좀 궁금했는데. 이번 기수부터는 선물도 그렇고 많이 바뀐 거 같습니다! 아직 핸드크림 향도 안 받아봤지만, 둘 다 잘 사용하도록 하겠습니다! 이 선물 받기 며칠 전이 생일이었던 터라, 더 이상 올 선물이 없는데? 하고 택배를 받았었는데, 에이블에서 제 생일을 챙겨준 듯한 느낌이 들어서 기분이 조금 좋았어요!ㅋㅋㅋ

⭐ ChatGPT를 수어로 사용하는, 웹서비스 데모 구현

총 7일 동안

• 데이터 파이프라이 구축
• 수어 번역 모델 생성 및 관리
• AWS 클라우드에 배포 환경 구축
• ChatGPT API 사용법 연구
• ChatGPT를 수어로 사용하는 웹 서비스 구현 을 진행했습니다!

사실 인생 처음으로 웹서비스를 구현하는거라 정말 힘들었습니다. 뭔지 모르고 굴러가는 얼레벌레 감자였어요.

그래도 이번 미니 프로젝트가 빅 프로젝트 하는데 많은 도움이 될 거라고 강사님께서 말씀해 주셔서! 힘들어도 눈물을 참고 열심히 했습니다..!

저는

• Home
• 회원가입/로그인
• Chatgpt페이지
• Signlanguage to chatgpt 페이지

중에서 Chatgpt 페이지를 담당했습니다!

현재 존재하는 Chatgpt처럼 Chaptgpt에게 질문하면 답변이 오는 형식입니다! 아무래도 원래 있는 chatgpt가 자꾸 생각나서, 저도 대화하는 형태로 웹페이지를 구성하였습니다! 보여드리고 싶은데, 차차 수정하면서 다시 올려보도록 하겠습니다!

사실 저희 조 중에는 웹 개발을 해보신 분이 없어서 정말 다들 힘들어하셨어요..ㅎㅎ 정말 마지막 단위 테스트부터 통합 테스트까지 끝내고 최종본을 배포하기 직전까지 계속해서 수정했습니다. 다른 조들 중에는 전날 끝내신 분들도 있더라고요! 정말 대단하신 거 같아요. 이제 전체 공유회 시간에 다른 조들 페이지도 구경하고 순위를 매기는데 확실히 프런트가 정말 중요하다는 것을 배웠습니다. 다들 기능이 거의 같아서 그런지 확실히 보이는 것이 예쁜 조들이 높은 점수를 가져가시더라고요. 빅프로젝트 할 때도 프런트 부분을 열심히 해야겠다 다짐했습니다!

🍚 맛집 추천

✔️ GTS버거 분당정자점

• 매일 10:30 - 22:20
• 경기 성남시 분당구 불정로87번길 4 1층 일부호
• GTS 치즈버거 7,900

조원이 먹어보고 싶다고 해서 GTS 버거를 드디어 먹어보았습니다! 배달 예정이 약 1시간 정도 걸린다고 해서 일찍 시켰는데, 30분 만에 와서 점심시간이 될 때까지 기다리다 보니 감자튀김이 다 식어버려서 너무 아쉬웠습니다.. 하지만 버거도 감자튀김도 다 식어버렸지만! 버거 하나는 정말 맛있었습니다! 가격은 사실 좀 수제 버거다 보니까 사악한 면이 있지만, 한 번쯤 먹어볼 만한 거 같아요!

제가 4기를 지원했던게 엊그제 같은데, 벌써 5기를 모집하는 순간이 왔네요!

사전 설명회가 필요하시다면, 위 QR링크를 사용해서 신청하시면 될 것 같습니다!

KT AIVLE SCHOOL의 장점이 전국 어디서나 참여할 수 있다는 거 같아요. 저는 비록 대전에 대학교를 다니면서 서울/경기권에 지원했습니다! 그래도 프로젝트 기간을 제외하고는 대전/대구/서울 어디서든지 제가 집중할 수 있는 공간에서 진행하였습니다! 이러한 부분들을 잘 숙지하시고 좋은 결정을 내리시면 될 거 같아요!

또 이 프로그램을 진행하면서 AI를 활용하고 데이터를 만져볼 수 있는 기회뿐만 아니라 새로운 사람들을 만나고, 그 사람들과 따로 스터디나 프로젝트를 진행할 수 있다는 점이 저는 제일 큰 장점이라고 생각해요. 프로젝트를 통해 많이 성장했지만, 저에게는 새로운 사람들과 공모전이나 어떠한 목표를 위해 프로젝트를 한다는 게 큰 용기였습니다. 절대 후회하지 않고, 잘 시작했다!라고 생각이 듭니다 ㅎㅎ 매일매일 9-6로 수업 듣는데 힘들지만! 그만큼 또 얻는 게 있으리라 생각했기에 시작할 수 있었고, 후회하지 않습니다! 그리고 이 분야의 부트 캠프는 사실 거의 없고, 또 벌써 5기를 모집할 만큼 많은 시행착오도 겪었기에, 5기 분들은 또 더 좋은 질의 수업과 프로젝트를 진행하실 수 있을 거라 생각됩니다.

궁금한 점이 있다면 언제든 댓글 주세요! 곰곰이 생각해 보고 또 찾아보고 답변드리겠습니다!

친구추천 이벤트!! 제 에이블 아이디도 적어도 되나요? ㅎㅎ 제 에이블 아이디는 a041048 입니다! 10명 추천하면 선물도 10개라니! 많이 탐나네요 ㅎㅎ

지원 자격은 다음과 같습니다! 지역 추천제! 졸업 예정자분들은 학과 홈페이지 한 번씩 보시면 좋을 거 같아요! 저는 이런 게 있는지 몰랐거든요! 물론 지원하려는 지역이 달라서 해당되지는 않았을 겁니다!! 본인이 다니는 대학교에 있는 지역에 지원하고 싶다! 하시면 지역 추천제를 노려보는 거 좋을 거 같습니다! 뭐든지 아는 것이 힘이니까요! 사용할 수 있는 수단은 다 써보자고요!

다음은 커피차 이벤트입니다!!

요즘 대학교에 커피차 이벤트 굉장히 많은 거 같아요. 학교에 있으면 종종 커피차 이벤트 덕분에 음료 마시는 경우가 있는데 너무 좋더라고요! 에이블 스쿨 인스타그램 팔로우하고 피드 작성 인증하면 KT 에이블 스쿨이 커피를 드립니다! 다들 한 잔씩 마셔요!! 선착 200분!!! 우리 학교에도 오는데, 저도 가고 싶네요!!!

참고로 에이블스쿨 인스타그램은 @aivlestory입니다!! 인스타그램에도 다양한 소식들이 업로드되어 있으니까! 팔로우 하면서 다양한 소식도 보고 가세요!

일정

AICE Associate - 특강 - 랜선 회식 순으로 진행되었다!

AICE Associate

사실 오픈북이라 걱정 반 자신감 반이었다! 시험 대비도 했었고, 그래도 혹시나 싶어서 시험 3-4일 전부터 하루에 하나씩 시험 대비 때 했던 것들을 질문만 보고 손으로 다시 적어보았다. 시험 때 찾아보면서 하면 되지만, 시험 준비할 때 몇 가지 새롭게 알게 된 것들이나, 그 문제의 흐름을 머리에 잡고 시험을 보고 싶었다. 시험 대비 때 열심히 했다면 무난하게! 통과할 수 있었을 것 같다 ㅎㅎ 그래서 그런지 무난하게 통과!! 1시간 반 시험이였지만, 1시간 만에 다 풀고 점심시간을 아주 길~~게 가질 수 있었다 ㅎㅎ

코딩 마스터스 시상

23.08.21. ~ 23.09.15. 4주동안 1차 코딩 마스터스가 진행됐었다!! 사실 나는 100문제 다 푸는 그랜드 마스터가 목표였지만, 어림도 없지.. 학교생활, 에이블, 이것저것 하느라 정신없이 살다 보니 알고리즘 공부가 멀어지고 머리가 굳어버렸다... 하지만 진짜 꾸역꾸역 주변 분들께 여쭤가면서 하다 보니 70문제 도달!! 다행히 마스터로 끝내게 되었습니다!! 짝짝짝..!! 그랜드 마스터는 키보드, 마스터는 마우스를 선물로 받았습니다!! 블루투스 키보드 필요했는데.. 너무 아쉽습니다!! 다음번에는 꼭 그랜드 마스터!! 하고 싶습니다!! (현재 2차 코딩 마스터스 진행 중인데, 너무너무 어렵네요 ㅠㅠ) 제 마우스는 로지텍 M650인데, 아직 제 마우스는 멀쩡해서, 나중에 써봐야겠어요! 그리고 받은 오픈 배지!! git에 쓸 수 있으면 좋겠지만 ㅠ linkedin에 사용해야겠습니다!

랜선 회식

드디어! 랜선 회식입니다! 사실 어떻게 진행되는지 궁금했습니다! 에이블 데이를 위해 며칠 동안 열려있던 '나를 찾아줘' 패들렛입니다!

나중에는 매우 변질된 모습이긴 하였지만.. 서로 칭찬과 고마운 점, 친해지고 싶은 마음 표현하는 게 너무 보기 좋았습니다!! 더더 친해지면 좋겠네요!

매니저님을 맞춰라!부터 시작해서 한 분씩 지금까지 중에 활동이나 느낀 점을 말하는 시간까지!! 다들 낯을 많이 가리시는 거 같지만, 조금씩이라도 목소리를 들어볼 수 있어서 좋았습니다!!

매니저님이 틈틈이 이전까지 진행해 주셨던 퀴즈들!!
정말 재밌었습니다!! 딱 잠이 올 때!를 어떻게 아시는 건지!
매니저님 덕분에 불태우면서 매번 열심히 퀴즈를 풀고 정신을 차렸습니다!!
제가 뭐가 제일 재밌었는지 기억이 안 난다고 했는데 ㅠㅠ 너무 전부 다!! 재밌어서!! 하나만 고르기에는 그 순간에 벙쪘던 거 같습니다!! 정말 정말 재밌었습니다 매니저님!ㅎㅎ
아, 이제야 말하지만 저는 이 문제가 가장 재미있었습니다!!
서로 겹치면 안 되기 때문에 저는 네이버 국어사전 20 페이지에서 찾았던 기억이 있네요..ㅎㅎ
덕분에 제일 머릿속에 제대로 기억하는 문제였습니다 ㅎㅎ

벌써 절반이 지났다는 게 많이 놀랍습니다.. 점점 빅프로젝트가 다가온다는 것도 믿기지 않고요. 앞으로도 열심히 해서 좋은 성과를 들고 잘 마무리할 수 있었으면 좋겠습니다! 다들 파이팅!

⭐ AIVLE School FAQ ChatBot

목표: Aivle School 지원 질문, 답변 챗봇 만들기

0. 배경 및 문제 정의

챗봇의 유용성

• 이용자는 챗봇을 통해 시간 절약, 사용자 경험 개선, 접근성 제고 가능
  • 인터넷이 접속되며 시간과 장소에 제약 없이 서비스 이용 가능함에 따라 대기 시간이나 방문시간 절약
• 디지털 서비스.기기의 이용 환경(혹은 사용자 경험) 개선
  • 추가적인 앱이나 프로그램 설치 없이 온.오프라인 서비스 이용 가능
• 정보역량에 관계 없이 원하는 결과 획득
  • 일상적인 대화 방식으로 쉽게 접근하여 정보 수집 가능

PAIN POINT

Aivle School 지원자들의 단순 반복 문의에 따른 업무 부담 증가 교육 운영담당자는 단순 반복 문의에 따른 업무 피로도 증대, 제한된 시간과 인력으로 인한 응대업무 한계 존재

• 교육 운영담당: 지원자들의 단순 반복 문의에 대해 늘어나고 있어, 업무 효율이 낮고 부담이 크다!
• 교육 지원자: 교육 관련 문의를 위해 메일로 요청했는데, 너무 오래 걸려 답답하다!

1. 데이터 탐색 및 전처리

데이터셋

일상대화	챗봇데이터

• 일상대화: 일상적인 질문과 답변
• 챗봇데이터: 에이블스쿨 지원 Q&A
• 두 데이터 셋을 통합하여 사용 → 약 1300여개

질문 별 문장 길이(글자 수)를 추출하여 분포

• 문장 길이도 상당히 짧다.
• 대부분 60자 이내이고, 평균적으로 18자 정도이다.
• 일상대화를 0, Q&A를 1로 지정 시 일상대화의 경우 평균 10자, 챗봇데이터의 경우 평균 23자 정도이다.

intent

• 30 intent까지가 일상대화에 대한 intent 그 이후는 챗봇데이터에 대한 intent이다.
• 보시다시피, 32 intent가 유독 많은 것을 볼 수 있다.
• 이 부분을 어떻게 해야할지 생각할 필요가 있다.

py-haspell

네이버 맞춤법 검사기를 이용한 파이썬용 한글 맞춤법 검사 라이브러리

• 따라서 A에 대한 Q를 출력해야하다보니, Q와 A에 맞춤법 검사기를 사용하면 좋을 거 같다고 생각했다.
  • 데이터의 일관성 - 동일한 의미를 가진 단어나 구문이 다르게 쓰여져 있으면, 이를 통일시킴으로써 모델이 더욱 정확하게 학습할 수 있을 것이라 생각했다.
  • 잘못된 정보의 최소화 - 맞춤법 검사기를 사용해 철자나 문장 구조를 수정하기에, 데이터에 포함된 잘못된 정보를 줄일 수 있다고 생각했다.

2. Aivle 스쿨 지원 질문, 답변 챗봇 만들기

챗봇1

Word2Vec을 활용하여 머신러닝 모델링

tokenized_sentences = [sentence.split() for sentence in clean_train.tolist()]

# Skip-gram: 중심에 있는 '타겟' 단어로부터 주변의 '문맥' 단어들을 예측
# CBOW: 주변의 '문맥' 단어들을 가지고, 그 중심에 있는 '타겟' 단어를 예측하는 방식

from gensim.models import Word2Vec

# Word2Vec 모델 생성
wv_model = Word2Vec(
    sentences = tokenized_sentences,
    vector_size = 100,
    window=5,
    min_count = 1,
    sg = 1
    )

# 'train'과 'test' 데이터셋의 'Q' 컬럼에 있는 각 문장을 토큰화
train['Q'] = train['Q'].apply(lambda x : tokenize('mecab', x).split())
test['Q'] = test['Q'].apply(lambda x : tokenize('mecab', x).split())

# 학습 데이터의 문장들을 Word2Vec 모델을 사용하여 벡터화
train_data_vecs = get_dataset(train['Q'], wv_model, 100)
test_data_vecs = get_dataset(test['Q'], wv_model, 100)

# X와 y 데이터 분리
x = train_data_vecs
y = train['intent'].values

# Train-Test split
x_train, x_val, y_train, y_val = train_test_split(x, y, test_size=0.2, random_state=42, stratify=y)

LightGBM

# LightGBM 분류기 생성
lgbm_model = LGBMClassifier()

# 학습
lgbm_model.fit(x_train, y_train)
lgbm_model.score(x_val, y_val)

# 예측 및 검증
y_pred = lgbm_model.predict(x_val)

from sklearn.metrics import accuracy_score

accuracy = accuracy_score(y_val, y_pred)
print('Validation Accuracy: ', accuracy)
# Validation Accuracy:  0.5188284518828452

RandomForest

# RandomForest
from sklearn.ensemble import RandomForestClassifier

# 학습
rf_model = RandomForestClassifier()
rf_model.fit(x_train, y_train)
rf_model.score(x_val, y_val)

# 예측 및 검증
y_pred = rf_model.predict(x_val)

from sklearn.metrics import accuracy_score

accuracy = accuracy_score(y_val, y_pred)
print('Validation Accuracy: ', accuracy)

# Validation Accuracy:  0.46443514644351463

챗봇 함수 만들기

def get_answer1(question):
    # token = twitter.morphs(question)
    token = tokenize('mecab', question)
    input_q = get_dataset([token], wv_model, 100)
    answer_list = train.loc[train['intent'] == lgbm_model.predict(temp)[0], 'A'].unique()
    answer_prob = train.loc[train['intent'] == lgbm_model.predict(temp)[0], 'A'].value_counts(normalize=True).values

    return np.random.choice(answer_list, 1, p=answer_prob)[0]


print(get_answer1('노트북 사양이 어떻게 되나요?'))

test 데이터에 대해 성능 측정

성능이 비교적 좋았던 LightGBM 사용

x_test = test_data_vecs
y_test = test['intent'].values

lgbm_model.score(x_test, y_test)
# 0.330188679245283

성능이 떨어지는 것을 볼 수 있다..

챗봇2

type 분류 모델링(LSTM)

데이터 준비

# 각각의 토큰에 인덱스 부여하는 토크나이저 선언
tokenizer = Tokenizer()

# .fit_on_texts 이용하여 토크나이저 만들기
tokenizer.fit_on_texts(clean_train_questions)

# 전체 토큰의 수 확인
print("전체 토큰의 수:", len(tokenizer.word_index))

# 전체 토큰의 수가 vocab 사이즈가 됨
vocab_size = len(tokenizer.word_index) + 1  # <PAD> 때문에 +1
print("Vocab size:", vocab_size)

# fit_on_texts을 위에서 한번만 해도 되지만, vocab 사이즈를 확인하고 줄이거나 하는 시도를 할 수도 있기에 다시 수행

# .texts_to_sequences : 토크나이즈 된 데이터를 가지고 모두 시퀀스로 변환
train_sequences = tokenizer.texts_to_sequences(clean_train_questions)
test_sequences = tokenizer.texts_to_sequences(clean_test_questions)

# 각 토큰과 인덱스로 구성된 딕셔너리 생성
word_index = tokenizer.word_index

# <PAD> 는 0으로 추가
word_index = {k:(v+1) for k,v in word_index.items()}
word_index["<PAD>"] = 0

max_len = 30

# pad_sequences 함수를 이용하여 시퀀스 데이터로 변환
train_padded = pad_sequences(train_sequences, maxlen=max_len)
test_padded = pad_sequences(test_sequences, maxlen=max_len)

train['type'].unique()
# array([0, 1])

y_train = train['type']
y_test = test['type']

문장별 토큰 수의 탐색적 분석

• 문장별 토큰이 가장 큰 것이 57개 입니다.
• 문장이 짧기 때문에 MAX_SEQUENCE_LENGTH는 정하지 않아도 되지만, 그러나 분포를 보고 적절하게 자릅시다. ▶ 30개면 충분할 거 같다!

모델링

토크나이징 한 데이터를 입력으로 받아 Embedding 레이어와 LSTM 레이어를 결합하여 이진 분류 모델링을 수행

# 임베딩 차원 설정
embedding_dim = 128

# LSTM 노드 수 설정
lstm_units = 64

# 모델 구성
dmodel = Sequential()
dmodel.add(Embedding(input_dim=len(tokenizer.word_index) + 1, output_dim=embedding_dim, input_length=max_len))
dmodel.add(LSTM(lstm_units))
dmodel.add(Dense(1, activation='sigmoid'))

# 모델 컴파일
dmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# 모델 요약 출력
dmodel.summary()

# 모델 학습
history = dmodel.fit(train_padded, y_train, epochs=10, batch_size=32, validation_split=0.2)

# 예측 수행
predictions = dmodel.predict(test_padded)

# 예측 결과를 0과 1로 변환
predictions = [1 if pred > 0.5 else 0 for pred in predictions]

from sklearn.metrics import accuracy_score

# 성능 평가
accuracy = accuracy_score(y_test, predictions)
print(f'Accuracy: {accuracy * 100:.2f}%')

# Accuracy: 100.00%

이번에는 100%!! 도대체 뭐지 싶었다.

FastText 모델 생성

from gensim.models.fasttext import FastText
import gensim.models.word2vec

# 모델 생성
ft_model = FastText(sentences = x_train,
                 min_count = 1,
                 vector_size = 100,
                 window = 5)

x_train = clean_train_questions.apply(lambda x: get_sent_embedding(ft_model, 100, x))
x_test = clean_test_questions.apply(lambda x: get_sent_embedding(ft_model, 100, x))

x_train = np.array(x_train.tolist())
x_test = np.array(x_test.tolist())

y_train_type = train['type'].values
y_test_type = test['type'].values

y_train_intent = train['intent'].values
y_test_intent = test['intent'].values

intent_clf = LGBMClassifier()
intent_clf.fit(x_train, y_train_intent)
intent_clf.score(x_test, y_test_intent)

test_input = train.loc[600, 'Q']
test_answer = train.loc[600, 'A']

temp = tokenizer.texts_to_sequences([test_input])
temp = pad_sequences(temp, maxlen=max_len, padding='pre', truncating='post')

type_pred = dmodel.predict(temp)

type_pred
#1/1 [==============================] - 0s 23ms/step
#array([[0.9997847]], dtype=float32)

# 이미 토큰화된 리스트를 임베딩 벡터로 변환
temp = get_sent_embedding(ft_model, 100, test_input)

from sklearn.metrics.pairwise import cosine_similarity

cosine_similarity(temp.reshape(1, -1), x_train).argmax()    # 531

def get_intent2(question):
    type_input = tokenizer.texts_to_sequences([test_input])
    type_input = pad_sequences(type_input, maxlen=max_len, padding='pre', truncating='post')
    type_pred = np.round(dmodel.predict(type_input.reshape(1, 30), verbose=0)[0][0])

    ft_vecs = get_sent_embedding(ft_model, 100, question)

    temp_df = train[train['type'] == type_pred].reset_index(drop=True)
    q_vecs = temp_df['Q'].apply(lambda x: get_sent_embedding(ft_model, 100, x))
    q_vecs = np.array([list(x) for x in q_vecs])

    answer_idx = cosine_similarity(ft_vecs.reshape(1, -1), q_vecs).argmax()
    intent_pred = temp_df.loc[answer_idx, 'intent']

    return intent_pred

y_pred = [get_intent2(x) for x in test['Q'].tolist()]
accuracy_score(test['intent'].values, y_pred)
# 0.29245283018867924

질문에 대한 답변 비교해보기

def get_answer1(question):
    token = tokenize('mecab', question)
    input_q = get_dataset([token], wv_model, 100)
    intent = lgbm_model.predict(input_q)[0]
    answer_list = train.loc[train['intent'] == intent, 'A'].unique()
    answer_prob = train.loc[train['intent'] == intent, 'A'].value_counts(normalize=True).values

    return np.random.choice(answer_list, 1, p=answer_prob)[0], intent

def get_answer2(question):
    type_input = tokenizer.texts_to_sequences([test_input])
    type_input = pad_sequences(type_input, maxlen=max_len, padding='pre', truncating='post')
    # type_pred = np.round(dmodel.predict(type_input.reshape(1, 30), verbose=0)[0][0])
    type_pred = (dmodel.predict(type_input.reshape(1, 30), verbose=0)[0][0] > 0.5).astype(int)

    ft_vecs = tokenize('mecab', question)
    ft_vecs = get_sent_embedding(ft_model, 100, ft_vecs)

    temp_df = train[train['type'] == type_pred].reset_index(drop=True)
    q_vecs = temp_df['Q'].apply(lambda x: get_sent_embedding(ft_model, 100, x))
    q_vecs = np.array([list(x) for x in q_vecs])

    answer_idx = cosine_similarity(ft_vecs.reshape(1, -1), q_vecs).argmax()
    intent_pred = temp_df.loc[answer_idx, 'intent']

    # print(type_pred, answer_idx, intent_pred)
    return temp_df.loc[answer_idx, 'A'], intent_pred

question = '에이블스쿨 지원하고 싶어요'

ans1, int1 = get_answer1(question)
ans2, int2 = get_answer2(question)
# ans3, int3 = get_answer3(question)

# print("="*120)
print("질문 :", question)
print("="*120)
print("챗봇1 답변 :", int1, ans1)
print("="*120)
print("챗봇2 답변 :", int2, ans2)
print("="*120)
# print("챗봇3 답변 :", int3, ans3)
# print("="*120)

❗마치며

사실 챗봇2부터는 꽤 어려웠다. 이전에 같은 프로젝트 한 다른 에이블 기수분들의 블로그가 아니였다면 한참 더 헤맸을 거 같다. 그래서 이번에 내 코드를 올린 이유이기도 하다. 내 코드가 좋은 코드다!는 아니지만, 이런코드도 있다!를 보여주고 싶었다. 사실 validation때 0.5넘게 나와서 나름 0.5넘게 나와서 기대를 했는데, test하면 0.3, 심하면 0.2까지 내려가는 것을 보고 너무 어이없고 화가 났다. 다른 분들 보니까 validation때 0.6, test 시 0.4로 내려가신 분도 있다고 들었다. 다들 어쩜 그리 잘하는지...나도 더욱 공부하고 분발해야겠다.

그리고 점점 하면서 느끼는데, 나는 자연어 처리가 나름 재미있는거 같다. 더 잘해보고 싶은데, 어떻게 해야할까? 더욱 찾아보고 공부하는 방법 뿐이겠지만, 다음에는 이 모델을 왜 쓰는지, 어떻게 하며 성능을 더 높일 수 있는지 생각해봐야겠다.

⭐ 스마트폰 센서 데이터 기반 인간 행동 인식 분류

목표: 스마트폰 기반의 센서 데이터를 활용해 동작을 분류하는 모델을 완성

1. 탐색적 데이터 분석

data.shape : (5881, 563) 칼럼이 너무 많다! 이걸 어떻게 분석해야 할까 생각하다가, 변수 중요도 상위 10개, 하위 10개만 살펴보자고 생각했다.

변수중요도 상위 10개, 하위 10개 확인

랜덤 포레스트는 튜닝 없이 하이퍼 파라미터의 기본값으로도 적절한 성능의 모델을 생성하므로, 랜덤 포레스트를 이용하여 변수 중요도 추출

target = 'Activity'

6개의 클래스로 구분하여 분류를 진행하므로 타깃 값 분포를 확인해 보았다.
countplot을 봤을 때는 데이터 분포가 고르다고 느끼지 못했으나, pieplot을 봤을 때 이 정도면 데이터 분포는 고른 거 같다고 생각했다.

2. 기본 모델링

사실 1번 파일에서 변수 중요도를 8개의 관점에서 뽑고 하나의 데이터프레임으로 합친 후 저장하였다. 그러나, 5차 프로젝트의 경우 AICE를 제외하고 3일 동안 진행되었다. 더욱이, 본 프로젝트는 캐글을 제외한 이틀 동안 진행되었다. 이러한 이유로, 변수중요도를 다양한 관점에서 뽑아 저장한 데이터 프레임은 사용되지 않았다.

스케일링

데이터프레임의 최댓값과 최솟값을 확인해 보았을 때, -1과 1임을 확인했다. 따라서 -1 ~ 1 사이에 모든 데이터가 분포하므로, 스케일링의 필요성을 느끼지 못했다.

머신러닝

best_model: Logistic Regression Model Accuracy: 0.9855564995751912

• 다른 분들의 의견을 들었을 때는 LGBM이나 XGBoost 성능이 더 좋았다는 의견도 있었습니다!
• 보시다시피 전체적으로 성능이 좋은 것을 볼 수 있었어요!

위 N개 변수를 선택하여 모델링 수행 및 성능 비교

아무래도, 기본적으로 성능이 좋다 보니, 칼럼을 어느 정도까지 줄여도 성능이 좋을까 하고 확인할 필요가 있었습니다!

변수 중요도 상위 N개를 10개씩 증가시켰을 때 가장 성능이 좋았던 모델:

Best Model with top 320 features, Accuracy: 0.9881053525913339

변수 중요도 상위 N개를 10개씩 증가시켰을 때, Early Stoppig 기법을 사용:

이전 3번의 반복에서 정확도가 0.01 이내로 변동하지 않으면 반복을 중단하고, 그 시점의 가장 높은 정확도를 가진 모델을 최종 모델로 선택

Best Model with top 30 features, Accuracy: 0.9804587935429057

3. 단계별 모델링

단계 1: 정적/동적 행동 분류 모델

def label_activity(activity):
    if activity in ['STANDING', 'SITTING', 'LAYING']:
        return 0
    else:
        return 1

data['Activity_dynamic'] = data['Activity'].apply(label_activity)
new_data['Activity_dynamic'] = new_data['Activity'].apply(label_activity)
data.head()

Best Model: LogisticRegression with Accuracy: 0.9821580288870009

단계2-1 : 정적 동작 세부 분류

• 정적 행동(Laying, Sitting, Standing)인 데이터 추출
• Laying, Sitting, Standing 를 분류하는 모델을 생성
• 몇가지 모델을 만들고 가장 성능이 좋은 모델을 선정

# 정적인 데이터 추출
static_data = data.loc[data['Activity_dynamic'] == 0]
static_data.head()

Best Model: RandomForestClassifier with Accuracy: 0.9752704791344667

단계2-2 : 동적 동작 세부 분류

• 동적 행동(Walking, Walking Upstairs, Walking Downstairs)인 데이터 추출
• Walking, Walking Upstairs, Walking Downstairs 를 분류하는 모델을 생성
• 몇가지 모델을 만들고 가장 성능이 좋은 모델을 선정

  # 동적인 데이터 추출
  dynamic_data = data.loc[data['Activity_dynamic'] == 1]
  dynamic_data.head()

  Best Model: LogisticRegression with Accuracy: 0.9905660377358491

분류 모델 합치기

• 두 단계 모델을 통합하고, 새로운 데이터(test)에 대해서 최종 예측결과와 성능평가가 나오도록 함수로 만들기
• 데이터 파이프라인 구축 : test데이터가 로딩되어 전처리 과정을 거치고, 예측 및 성능 평가 수행

from sklearn.model_selection import train_test_split
import numpy as np

x = data.drop(columns='Activity')
y1 = data['Activity']
y_dynamic = y1.copy().map(lambda x: 1 if x in ['WALKING', 'WALKING_UPSTAIRS', 'WALKING_DOWNSTAIRS'] else 0)

static_indices = y1.isin(['LAYING', 'SITTING', 'STANDING'])
x_static = x[static_indices]
y_static = y1[static_indices]

acting_indices = y1.isin(['WALKING', 'WALKING_UPSTAIRS', 'WALKING_DOWNSTAIRS'])
x_act = x[acting_indices]
y_act = y1[acting_indices]

x_train, x_valid, y_train, y_valid = train_test_split(x, y1, test_size=0.2, random_state=0)
x_train_dynamic, x_valid_dynamic, y_train_dynamic, y_valid_dynamic = train_test_split(x, y_dynamic, test_size=0.2, random_state=0)
x_train_act, x_valid_act, y_train_act, y_valid_act = train_test_split(x_act, y_act, test_size=0.2, random_state=0)
x_train_static, x_valid_static, y_train_static, y_valid_static = train_test_split(x_static, y_static, test_size=0.2, random_state=0)

model_dynamic = RandomForestClassifier()
model_dynamic.fit(x_train_dynamic, y_train_dynamic)

model_act = RandomForestClassifier()
model_act.fit(x_train_act, y_train_act)

model_static = RandomForestClassifier()
model_static.fit(x_train_static, y_train_static)

y_pred_dynamic = model_dynamic.predict(x_valid)
y_pred_act = model_act.predict(x_valid)
y_pred_static = model_static.predict(x_valid)
y_pred_total = []

for i in range(len(y_pred_dynamic)):
    if y_pred_dynamic[i] :
        y_pred_total.append(y_pred_act[i])
    else:
        y_pred_total.append(y_pred_static[i])
accuracy_dynamic = accuracy_score(y_valid, y_pred_total)
print(f"Accuracy = {accuracy_dynamic}")

Kaggle Competition

짧게 적어보자면..

1. timestamp

나는 처음 '스마트폰 센서 데이터 기반 인간 행동 인식 분류'에서 timestamp는 그다지 필요 없는 칼럼이라 생각하고 칼럼 자체를 삭제했었다. 삭제하고 모델 성능을 높이려고 아무리 노력해도 다른 사람들의 성능을 따라잡을 수 없었다. 그래서 그럼 timestamp를 한 번 넣어볼까?라고 생각하고, 넣었더니.. 헉!! 성능이 말도 안 되게 높아졌다!! 이것이 이 프로젝트의 사기였음을.. 사실 왜 성능이 좋아지는지 잘 모르겠지만, 연도에 따라 사용하는 사람의 수도 많아졌을 수도 있고, 등등의 이유와, 시간대에 따라 직장인들이 앉아있거나, 퇴근 출근 시간대에는 비교적 많이 움직일 테니까, 성능을 높이는데 중요한 feature가 될 수 있었다고 생각한다.

2. 결측치

test 데이터를 확인했을 때, 결측치가 하나도 없어서, 처음에는 결측치를 다 삭제했다. 하지만 성능을 어떻게 조금만이라도 더 올려볼까 고민하다가 각 칼럼의 mean 값으로 넣어봤더니 좀 더 높아진 것을 확인해 볼 수 있었다. 결측치 mean과 모델을 'RandomForestClassifier'이나 'KNeighborsClassifier'을 했을 때, accuracy가 0.9833 정도의 결과가 나왔다. 다른 더 점수가 높은 분들께 여쭤보니 해당 칼럼의 median 값으로 결측치를 채우고, 'LGBMClassifier'를 사용했더니 높게 나왔다고 말씀해 주셨다. 또 다른 분은 결측치를 '스플라인 보간법'을 사용하셨다고 한다. 결측치.. 크게 생각 못 했지만, 이것도 성능을 좌지우지한다는 것을 느꼈다..

🍚 맛집 추천

✔️ 라이라이

• 매일 11:00 - 22:30
• 경기 성남시 분당구 내정로11번길 10-4 1층
• 유니짜장면 8,000
• 등심탕수육 소 23,000

짜장면이 너무 먹고 싶어서, 중국집 어떻냐고 여쭤보니 다들 찬성해 주셔서 다녀왔습니다!
이 집은 탕수육 튀김옷이 찹쌀? 인 것으로 알고 있습니다! 아주아주 맛있습니다!!! 다들 꼭 드세요!! 화붐은 간짬뽕 맛집이지만, 전 짬뽕을 안좋아하는 관계로 이 집에이 제일이네요..ㅎㅎ
짜장면도 아주 맛있고요, 간짜장, 삼선짜장에 계란 프라이도 올라갑니다!! 다들 맛있다고 하시더라고요 ㅎㅎ 이날 제가 속이 안 좋아서, 제대로 못 먹었는데.. 다음번에 다시 또 가봐야겠습니다!
아 사진은... 먹느라 자꾸 까먹어서 주변 분들 나눠드리고, 짜장면 섞으려다 찍었습니다..ㅎㅎ 이제는 같은 팀원 분들이 제 velog를 챙겨주시네요.. 팀원분들 아니었으면 사진도 못 찍었을 거 같아요.. 감사합니다 ㅎㅎ

✔️ 대세신당동즉석쌀떡볶이&양푼이매운갈비찜국물닭발

• 매일 11:00 - 22:30
• 경기 성남시 분당구 불정로77번길 14
• 신당동 즉석 쌀 떡볶이 15,000
• 매운갈비찜 중 33,000

여기 오기 전날, 떡볶이가 먹고 싶어서, 근처에 떡볶이집이 있나 찾던 와중에 떡볶이랑 매운 갈비찜을 동시에 파는 집이 있었습니다! 아침에 팀원들을 보자마자 우리 이 집 가는 거 어떻냐고 여쭤봤는데 다들 흔쾌히 좋다고 해주셔서!! 감사합니다!! 떡볶이보다는 매운 갈비찜이 더 맛있었어요! 저희는 기본 맛을 먹었지만, 매워하시는 분들도 계셨고, 저는 맵지는 않았어요! 다음번에는 이거 큰 거 시켜서 밥이랑 같이 먹고 싶네요 ㅎㅎ 다른 집들보다는 조금 아쉬웠지만...! 그래도 맛있고 배부르게 잘 먹고 왔습니다!

❗마치며

사실 캐글을 진행하는 날, 학교 중간고사 일정이 있어서, 두 시에 조퇴를 했습니다. 하지만 이번에는 개인으로 진행하는 캐글... 50등 안에 너무나도 들고 싶더라고요.. 그래서 서울에서 대전으로 가는 고속버스 안에서 열심히 했지만, 아쉽게도 80등! 너무너무 아쉬웠지만, 캐글 끝나고 다른 분들께 어떻게 진행하셨는지 여쭤보면서, 제가 생각하지 못했던 부분들을 깨달았습니다! 다음번에는 더 잘하고 싶네요! 결측치를 어떻게 채우는지, 어떤 모델을 사용할 건지 정말 깊고 다양하게 생각해 보는 것이 좋을 거 같습니다!

미니프로젝트 5차 10.23.-10.27. 중 10월 23, 24 이틀 동안 AICE 대비를 했습니다!

내용도 복습할 겸, AICE 샘플문항을 통해 정리해보고자 합니다!

1. 파이썬 패키지 불러오기

import sklearn as sk
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

2. 데이터 파일 읽어오기

df = pd.read_json(path) df = pd.read_csv(path)

3. 분포도 알아보기

count plot

sns.countplot(data = df, x = 'Address1')
plt.show()

idx_address = df.loc[df['Address1'] == '-'].index
df.drop(idx_address, inplace = True)

joint plot

sns.jointplot(x='Time_Driving', y='Speed_Per_Hour', data=df)
plt.show()

4. jointplot 그래프에서 시속 300이 넘는 이상치 삭제

idx_out = df.loc[df['Speed_Per_Hour'] > 300].index
df.drop(idx_out, inplace = True)
df_temp = df.copy()

5. 결측치 처리

print(df_temp.isnull().sum())
df_na = df_temp.dropna()
print(df_na.isnull().sum())

6. 불필요한 변수 삭제

df_del = df_na.drop(['Time_Departure', 'Time_Arrival'], axis = 1)

7. 원-핫 인코딩(One-hot encoding)

df_del.info()
object_cols = df_del.select_dtypes(include='object').columns
df_preset = pd.get_dummies(df_del, columns=object_cols)

원하는 데이터타입 컬럼 추출: select_dtypes

8. target 컬럼에 대해 데이터 셋 분리

from sklearn.model_selection import train_test_split

target = 'Time_Driving'
y = df_preset[target]
X = df_preset.drop('Time_Driving', axis=1)

X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.2, random_state=42)

9. 머신러닝 및 성능 평가

from sklearn.tree import DecisionTreeRegressor

model = DecisionTreeRegressor(max_depth=5, min_samples_split=3, random_state=120)
model.fit(X_train, y_train)

from sklearn.metrics import mean_absolute_error

y_pred = model.predict(X_valid)
dt_mae = mean_absolute_error(y_valid, y_pred)

10. 딥러닝

import tensorflow as tf
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import Dense, Activation, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.utils import to_categorical

tf.random.set_seed(1)

• 모델링하고 학습을 진행

  # 여기에 답안코드를 작성하세요.
  from sklearn.metrics import mean_squared_error
  

model = Sequential([ Dense(64, activation='relu', input_shape=(X_train.shape[1],)), BatchNormalization(), Dropout(0.2),

Dense(32, activation='relu'),
BatchNormalization(),
Dropout(0.2),

Dense(16, activation='relu'),
BatchNormalization(),
Dropout(0.2),

Dense(1)

])

model.compile(optimizer = 'adam', loss = 'mean_squared_error')

history = model.fit(X_train, y_train, batch_size = 16, epochs = 30, validation_data=(X_valid, y_valid))

</br>
- Matplotlib 라이브러리 활용해서 학습 mse와 검증 mse를 그래프로 표시

mse = history.history['loss'] val_mse = history.history['val_loss']

epochs = range(1, len(mse) + 1)

plt.plot(epochs, mse, 'b', label='mse') plt.plot(epochs, val_mse, 'r', label='val_mse')

plt.title('Model MSE') plt.xlabel('Epochs') plt.ylabel('MSE') plt.legend() plt.show()

![](https://velog.velcdn.com/images/harii-in/post/e517fde1-70ad-4045-baac-59c840139e59/image.png)

</br>
<피드백> </br>
- loss='mean_squeared_error'해서 metrics 안써도 자동으로 되네요!

---
### 🧐 후기
AICE 처음이라 걱정 많이했지만!
세 개의 프로젝트? 연습을 진행하며 생각보다 괜찮겠구나! 그래도 지금까지 열심히 공부했구나를 느꼈다!! 그래도 중간중간 원하는 데이터타입 컬럼 추출이나 팀 같은 것들을 팀원들끼리 주고 받으면서 재미있었다!!
연습한 것 보다 어렵게 문제가 나온다고 하니, 시험 전에 세 개 다시 해보고, 추가적으로 공부를 좀 더 해야할 거 같다! 그리고 점점 나만의 머신러닝, 딥러닝 적는 방법이 생기는 거 같아 뭔가 뿌듯하고...신기하고...!

+) 우리 팀원들...익명으로 하니까 말 되게 많아졌어요...

![](https://velog.velcdn.com/images/harii-in/post/d5d0a625-f5ba-4146-9e0f-0b101cf1b43a/image.png) |![](https://velog.velcdn.com/images/harii-in/post/8ba88876-a7fa-4d8e-95e0-a21e11b1f889/image.png)
---|---|

⭐ AIVLE-EDU 1:1 문의 유형 분류하기 목표: AIVLE SCHOOL TUTORING CENTER의 업무 고도화를 위해 1:1 질문 게시판에 업로드 되는 에이블러들의 질문 유형을 자동으로 분류해주는 모델을 만들고 성능을 개선한다.

1. 데이터 분석 및 전처리

먼저 데이터는 각 문의 내용에 대해 label이 '코드2', '웹', '이론', '코드1', '시스템 운영', '원격'로 분류되어 있다. 문의 내용 중 길이가 제일 긴 인덱스는 2561번으로 길이가 6012이다.

이 프로젝트를 어떻게 진행할까 팀원들과 이야기를 하면서 영어, 특수 문자, 숫자를 모두 제거하고 'NNG(일반명사)', 'NNP(고유명사)' 품사에 해당하는 단어만 추출하여 분석을 진행하기로 결정했다. 추가로, 한글 단어 중에서 한 글자로 이루어진 단어를 확인해 보니, 제대로 처리되지 않은 조사나 이해하기 어려운 단어가 많았다. 이를 보완하기 위해 한 글자 단어를 삭제한 데이터프레임과 그렇지 않은 데이터프레임 두 가지를 만들어 분석을 진행했습니다.

#  'NNG(일반명사)', 'NNP(고유명사)' 품사만 추출
def extract_nouns(text, target = ['NNG','NNP'], to_list=True):
    # ['NNG','NNP','NP','NNB','NNBC','NR']

    nouns_list = []
    pod_text = mecab.pos(text)
    for s in pod_text:
        if s[1] in target:
            if to_list:
                nouns_list.append(s[0])
            else:
                nouns_list.append(s)

    return nouns_list

텍스트 데이터를 처리하는 과정에서 중복 단어를 제거할지에 대한 고민을 많이 했다. 그러나 단어가 여러 번 반복될수록 그 문장에서 해당 단어가 중요한 요소로 작용할 수 있을 거라 생각했다. 단어의 빈도가 그 중요성을 나타내는 경우가 많기 때문에, 중복 단어를 제거하지 않기로 결정했다.

벡터화 - N-grams

벡터화는 문서를 벡터로 변환하는 과정이다. 여기서 n-gram은 글자/단어를 n 개씩 묶는 것이다. 만약에 n을 2로 설정한다면 '토마토'를 ['토마', '마토', '토토'] 이렇게 두 글자씩 묶어준다. 이 과정을 통해 문장의 문맥을 이해하는 데 도움이 된다고 한다.

# 확인
ngram_list = []

for f in f_nouns:
    tmp = []
    two_gram = zip(f, f[1:])
    for i in two_gram:
        tmp.append(i[0] + i[1])
    ngram_list.append(tmp)

print(ngram_list)

TF-IDF는 단어의 빈도수에 따라 가중치를 부여한다. 따라서 TF-IDF 값이 높은 단어일수록 해당 문서에서 중요한 단어로 간주된다. n-gram에 TF-IDF를 적용함으로써 텍스트 데이터를 더욱 효과적으로 분석하고 이해할 수 있다고 한다... 사실 이 부분은 완전히는 이해하지 못했다. 차차 공부하다 보면 더 잘 알겠지..

def identity_tokenizer(tokens):
    return tokens

count_vectorizer = CountVectorizer(tokenizer=identity_tokenizer, lowercase=False)
count_mecab_vectorizer = CountVectorizer(tokenizer = mecab_tokenizer, lowercase=False)

x_tr_counts = count_vectorizer.fit_transform(X_tr["noun"])
x_val_counts = count_vectorizer.transform(X_val["noun"])
x_te_counts = count_vectorizer.transform(X_te)

x_tr_mecab_counts = count_mecab_vectorizer.fit_transform(X_tr["noun"])
x_val_mecab_counts = count_mecab_vectorizer.transform(X_val["noun"])
x_te_mecab_counts = count_mecab_vectorizer.transform(X_te)

transformer = TfidfTransformer()
x_tr_tfidf = transformer.fit_transform(x_tr_mecab_counts)
x_val_tfidf = transformer.transform(x_val_mecab_counts)
x_te_tfidf = transformer.transform(x_te_mecab_counts)

tfidf_vectorizer = TfidfVectorizer(tokenizer=identity_tokenizer, lowercase=False)
x_tr_tfidfv = tfidf_vectorizer.fit_transform(X_tr["noun"])
x_val_tfidfv = tfidf_vectorizer.transform(X_val["noun"])
x_te_tfidfv = tfidf_vectorizer.transform(X_te)

print("Count Vectorizer Vocabulary size : ", len(count_vectorizer.vocabulary_))
print("Count Vectorizer(Mecab tokenizer) Vocabulary size : ", len(count_mecab_vectorizer.vocabulary_))
print("TF-IDF Vectorizer(Mecab tokenizer) Vocabulary size : ", len(tfidf_vectorizer.vocabulary_))

임베딩 - Sequence

주로 단어나 문장 등의 시퀀스 데이터를 저차원의 벡터로 임베딩하는 과정을 의미한다.

%%time
import tensorflow as tf
import numpy as np
import tensorflow.keras as keras
from keras.preprocessing import sequence
from keras.preprocessing import text
TOP_K = 5000
MAX_SEQUENCE_LENGTH = 500

X_mor_tr_str = X_tr["noun"].apply(lambda x: ' '.join(x))
X_mor_val_str = X_val["noun"].apply(lambda x: ' '.join(x))

X_mor_tr = X_tr["noun"]
X_mor_val = X_val["noun"]

tokenizer = text.Tokenizer(num_words=TOP_K, char_level=False)
tokenizer.fit_on_texts(X_mor_tr)
X_mor_tr_seq = tokenizer.texts_to_sequences(X_mor_tr)
X_mor_val_seq = tokenizer.texts_to_sequences(X_mor_val)

max_length = len(max(X_mor_tr_seq, key=len))
if max_length > MAX_SEQUENCE_LENGTH:
    max_length = MAX_SEQUENCE_LENGTH

print(max_length)
X_mor_tr_seq = sequence.pad_sequences(X_mor_tr_seq, maxlen=max_length)
X_mor_val_seq = sequence.pad_sequences(X_mor_val_seq, maxlen=max_length)

임베딩 - Word2Vec

이 부분은 애초에 함수가 제공되었다.

# 아래 함수는 제공합니다.
def get_sent_embeddings(model, embedding_size, tokenized_words):

    # 단어 임베딩 및 n_words의 크기가 0인 feature_vec 배열을 0으로 초기화합니다.
    # 또한 model.wv.index2word를 사용하여 Word2Vec 모델의 어휘에 단어 세트를 생성합니다.
    feature_vec = np.zeros((embedding_size,), dtype='float32')
    n_words = 0
    index2word_set = set(model.wv.index_to_key)

    # 토큰화된 문장의 각 단어를 반복하고 Word2Vec 모델의 어휘에 존재하는지 확인합니다.
    # 그렇다면 n_words가 증가하고 단어의 임베딩이 feature_vec에 추가됩니다.
    for word in tokenized_words:
        if word in index2word_set:
            n_words += 1
            feature_vec = np.add(feature_vec, model.wv[word])

    # Word2Vec 모델의 어휘에 있는 입력 문장에 단어가 있는지 확인합니다.
    # 있다면 feature_vec를 n_words로 나누어 입력 문장의 평균 임베딩을 구합니다.
    if (n_words > 0):
        feature_vec = np.divide(feature_vec, n_words)

    return feature_vec
def get_dataset(sentences, model, num_features):

    # 각 문장에 대한 임베딩을 보유할 dataset이라는 빈 목록을 초기화합니다.
    dataset = list()

    # 문장의 각 문장을 반복하고 앞에서 설명한 get_sent_embeddings() 함수를 사용하여 문장에 대한 평균 임베딩을 생성합니다.
    # 결과 문장 임베딩이 데이터 세트 목록에 추가됩니다.
    for sent in sentences:
        dataset.append(get_sent_embeddings(model, num_features, sent))

    # 루프에서 생성된 문장 임베딩을 sent_embedding_vectors라는 2차원 배열에 쌓습니다.
    sent_embedding_vectors = np.stack(dataset)

    return sent_embedding_vectors

2. 모델링

머신러닝에는 보통 벡터화된 데이터를, 딥러닝에는 임베딩된 데이터를 넣어줘야 한다.

머신러닝

• N-gram으로 전처리한 데이터를 이용하여 3개 이상의 Machine Learning 모델 학습 및 성능 분석

딥러닝

• Sequence로 전처리한 데이터를 이용하여 DNN, 1-D CNN, LSTM 등 3가지 이상의 deep learning 모델 학습 및 성능 분석 DNN Model Accuracy: 0.684636116027832 1D CNN Model Accuracy: 0.5053908228874207 LSTM Model Accuracy: 0.43800538778305054

3. Kaggle

내 성능은 꽝이었지만! 다들 전처리를 다양하게 나눠서 한 덕분에 결론적으로 우리 팀은 27개 조 중에 10등으로 마무리할 수 있었다! 캐글 처음이지만.. 너무 재밌어!!

🍚 맛집 추천

이번 미프 때는 비도 오고 그래서... 배달을 시켜 먹었습니다! 아무래도, 음식물이 남으면 안 되니까, 안 생기는 음식으로 최대한 골랐습니다!

✔️ 노모어피자 분당정자점

• 매일 11:00 - 24:00
• 경기 성남시 분당구 정자일로 135 3차 푸르지오 시티 D동 1층 103호
• 스윗 고구마 피자 L 27,800
• 콰트로 치즈 피자 L 28,800

피자.. 오랜만에 먹었는데 정말 맛있네요!
아무래도 피자가 먹다 보면 좀 느끼한 점이 있어서, 보통 하나는 좀 매운 거 해야 하는데, 고구마랑 치즈 피자로 해서, 마지막엔 많이 느끼했답니다..
다음부터는 생각하고 시키기... 하지만!!! 맛있었다❤️

✔️ 두찜 분당미금점

• 매일 10:45 - 22:45
• 경기 성남시 분당구 미금로 251 상가동 106호
• 까만 찜닭, 빨간 찜닭 23,800

전날 피자로 다들 니글니글해져서 그런지 이번에는 꼭 밥! 먹기로 했습니다!
뭘 먹다고 고민하다가, 제가 찜닭을 좋아해서 찜닭 어떤지 여쭤봤는데 다들 좋다고 하셔서 두찜 먹기로 했습니다!
까만 찜닭 2단계, 빨간 찜닭 3단계로 시켜 먹었는데, 생각보다 많이 순해서 다음번에는 한 단계씩 더 높여서 먹기로 했습니다!
밥이 생각보다 양이 적어 보였는데, 먹다 보니 양은 충분하더라고요! 한 팀이 두 개 시켜서 각자 밥이랑 같이 드시면 아주 풍족하고 배부르게 드실 수 있을 듯합니다! 다음번에 또 먹어야지 ㅎㅎ
아무래도 시켜 먹으니까, 나가서 먹는 것보다 시간적 여유가 많이 생기더라고요. 안 나가도 되고, 음식 나올 때까지 기다리는 시간이 줄어드니까요. 그래도 어쩔 수 없이 어느 정도 음식물은 생겨서, 자주 시켜 먹진 못할 거 같아요. 그래도 한 번쯤은..?ㅎㅎ

❗마치며

나는 'NNG(일반명사)', 'NNP(고유명사)' 품사에 해당하는 단어만 추출하여 분석을 진행했습니다. 하지만 성능은 결과적으로 한국어 뿐만 아니라, 영어와 특수문자를 넣은것이 성능이 제일 좋았습니다! 결론적으로는 역시 데이터가 많을수록 성능이 좋다는거... 정말 열심히 전처리 했으나, 참 어이없고...열불도 나지만, 이렇게 또 하나 배운거겠죠? 제가 다른 프로젝트를 진행하면서 불용어 처리와 맞춤법 검사기!를 사용한 적이 있어서, 이번에도 이렇게 진행해야 할까? 하다가 일단 명사만 추출하는 방법으로만 진행했습니다. 하지만 전체 발표할 때, 1등 팀이 불용어를 진짜로 하나하나 보고 제거하셨고, 2등 팀이 맞춤법 검사기를 사용했다고 들었습니다! 다른 팀들의 발표를 보며, 아! 우리도 할걸!!이라고 생각했지만, 그 팀 분들이 대단하신 거죠 ㅎㅎ 다음번엔 저도 포기하지 않고 집념으로 한 번 제대로 불용어처리 해봐야겠습니다!

참고

• 한국어 불용어 처리 한국어 불용어 리스트 100개 보통 사람들이 만들어 둔 불용어 리스트에서 각자 데이터 프레임을 확인하며 처리해야 할 불용어를 추가하여 처리하는 방법으로 알고 있다. 다른 좋은 방법 있으면 공유 부탁드립니다!🙏🏻

• 한국어 전처리 패키지

  # Py-Hanspell
  # 한국어 전처리 패키지
  # 네이버 한글 맞춤법 검사기를 바탕으로 만들어진 패키지로써 맞춤법을 고친 문장을 반환
  

!pip install git+https://github.com/haven-jeon/PyKoSpacing.git --no-deps argument

⭐ 서울시 공공 데이터 기반, 서울시 생활인구 예측

목표: 서울의 생활인구 데이터를 분석하여, 특정 지역의 생활인구를 파악하고 해당 지역의 생활인구를 예측한다

데이터

• 특정 시점을 기준으로 일정시간 동안에 유입, 유출, 이동한 총 인구
• 생활인구: 특정(조사) 시점에 존재하고 있는 사람의 수

1. 데이터 분석(EDA)

기본 데이터는 서울시 특정구 특정동의 생활인구 데이터가 주어졌다. train 데이터의 경우 2017년부터 2021년까지의 데이터를 합쳐서 사용하였고, test 데이터의 경우 2022년의 반년치 데이터만 주어졌다.

컬럼은 총 31개였고, 다음과 같다. 이 칼럼들을 보면서 너무 나눠져있는 연령대를 좀 합칠 필요가 있다고 판단했다. 따라서 생애 주기 단계에 맞춰 청소년(13세 이상 19세 미만인 사람), 성인(19세부터 30세까지), 장년(30세부터 45세까지), 중년(45세부터 64세까지), 노인(65세 이상)으로 합침으로써 구분하였다. 따라서 오직 생애 주기로 만 나눈 데이터와, 생애 주기에서 여성과 남성으로 나눈 데이터까지, 총 두 개의 데이터 프레임을 구성하였다.

다음은 시간대별로 '총 생활 인구수'의 변화를 나타내는 그래프이다.

2. 데이터 전처리

1. '기준일ID'열을 datetime 형식으로 변경 후 dt.year, dt.month, dt.day, dt.weekday를 진행후 가변수화를 진행하였다. 하지만, 22년 데이터의 경우 반년치 데이터 밖에 없다보니까, 칼럼의 갯수가 맞지 않는 문제가 발생하였다. 따라서 '기준일ID'열은 삭제하고 진행하였다.
2. shift와 rolling을 이용 원 데이터는 1시간대로 나뉘어진 시계열 데이터이기 때문에 미래시점의 인구를 예측하는 것이다. 따라서 하루 전 그 시간대, 7시간 동안의 이동평균, 3시간전까지의 평균, 바로 직전 1시간 전의 데이터를 가져왔다.

   df_total['1d예측'] = df_total['총생활인구수'].shift(24)
   df_total['이동평균 수'] = df_total['총생활인구수'].rolling(7, min_periods = 1).mean()
   data_total['3h_mean'] = data_total['총생활인구수'].rolling(3, min_periods = 1).mean()
   data_total['1h_before'] = data_total['총생활인구수'].shift(1)

   3. 모델링

   LinearRegression, RandomForestRegressor, GradientBoostingRegressor, KNeighborsRegressor, XGBRegressor 총 5개 모델로 진행했다. 아래 사진은 GradientBoostingRegressor의 변수 중요도이다. 참고로 왼쪽은 shift와 rolling을 진행한 칼럼만 남겨둔 데이터 프레임에 대한 변수 중요도, 오른쪽은 생애 주기로 합치고 shift와 rolling을 진행한 데이터 프레임이다. 보시다시피, 직전 3시간 전까지의 평균이 아주 높은 변수 중요도를 차지하고 있는 것을 볼 수 있다. 이는 GradientBoostingRegressor이 아닌 다른 모델 또한 마찬가지였다. 그 덕에 전체적으로 좋은 성능이 나왔음을 확인했다. 왼쪽 R2-Score: 0.9841506948197996 오른쪽 R2-Score: 0.9909533353119533

❗마치며

사실 시계열 데이터를 다룰 때, shift와 rolling이 중요하다는 점은 알고 있었지만, 오늘처럼 다른 그 어떤 데이터보다, 내가 전처리한 rolling 하나로 성능이 좋게 나왔음을 확인했다. 다음부터는 더더욱 왜?라고 생각하며, shift와 rolling을 진행해야겠다. 이렇게 뭔가 하나하나 배워가는 중...

⭐ 장애인 이동권 개선을 위한 장애인 콜택시 대기시간 예측 *💡목표 * 장애인 콜택시를 이용하는 고객들의 불편사항을 개선하고 서비스의 품질을 높이기 위해 콜택시 운행이 종료된 시점에 다음 날의 기상 예보를 바탕으로 기상 상황에 따른 장애인 콜택시의 평균 대기 시간을 예측하고 예상 대기 시간을 제공할 수 있는 모델을 완성하여 교통약자의 이동 편의 증진에 기여한다.

1. 데이터 전처리

• 목표: 전날 저녁, 다음날 평균 대기시간을 예측

  # 익일의 대기시간(waiting time)을 오늘의 데이터를 활용하여 예측 해야하는 대상(target)으로 설정
  

target = 'waiting_time' data['waiting_time_1'] = data[target].shift(-1)

target 변수에 NaN이 포함된 행 제거 -> 2022-12-31 행 제거

data.dropna(subset=['waiting_time_1'], axis=0, inplace=True)

* 날씨 데이터는 실제 측정값이지만, 다음 날에 대한 예보 데이터로 간주
```python
# 익일의 실제 날씨 데이터를 전일에 발표된 예보데이터로 판단
weather['Date'] = weather['Date'].shift(1)  # 2012-01-02 -> 2012-01-01

• 장애인 이동 데이터를 기준으로 날씨 데이터 merge data = pd.merge(data, weather, on='Date', how='inner')

새로운 feature 생성

• 날짜와 관련된 변수 추가 - 요일, 월, 계절, 연도

  • # 월을 기반으로 계절 분류
    def assign_season(month):
    if month in [12, 1, 2]:
      return 'Winter'
    elif month in [3, 4, 5]:
      return 'Spring'
    elif month in [6, 7, 8]:
      return 'Summer'
    else:
      return 'Fall'
    

data['year'] = data['Date'].dt.year # 연도 data['season'] = data['Date'].dt.month.apply(assign_season) # 계절

Object로 만드는 방법1

import calendar data['month'] = data['Date'].dt.month # 월 data['month'] = data['month'].apply(lambda x: calendar.month_abbr[x]) # 월 이름으로 만들기 # Jan, Feb, ... data['weekday'] = data['Date'].dt.weekday # 요일 data['weekday'] = data['weekday'].apply(lambda x: calendar.day_abbr[x]) # 요일 이름으로 만들기 # Mon, Tue, ...

categorical로 만들기

data['season'] = pd.Categorical(data['season'], categories=['Spring', 'Summer', 'Fall', 'Winter']) data['month'] = pd.Categorical(data['month'], categories=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']) data['weekday'] = pd.Categorical(data['weekday'], categories = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']) # ordered=True : 데이터프레임을 이 기준으로 정렬할건지

* 공휴일 정보
    * workalender 패키지로 대한민국 공휴일 정보 추가
    * 실제로 휴무일에 해당하지만 라이브러리에 없는 날짜 추가
        * 주말 추가!
```python
# ex
from workalendar.asia import SouthKorea
cal = SouthKorea()

holiday = pd.DataFrame(cal.holidays(2023))

• 7일 이동평균 대기시간 data['waiting_time_MA7'] = data['waiting_time'].rolling(7, min_periods = 1).mean() # min_periods : 최소 데이터수

• 탑승률 data['ride_rate'] = data['ride_cnt'] / data['request_cnt']

2. 탐색적 데이터 분석(EDA)

target = 'waiting_time'

숫자 feature → Target

fare	car_cnt	request_cnt

target과 feature의 산점도를 확인했을 때, 두 종류로 나뉘는 듯이 분포가 나왔다. 이 점에 대해 팀원들과 논의하고 확인한 결과, 쉬는 날과 일하는 날로 나뉘기 때문인 것으로 밝혀졌다.

범주 feature → Target

holiday	season

month	weekday

변수 정리

• 강한 관계
  • 7days_mean, ride_rate
• 중간 관계
  • request_cnt, car_cnt
• 약한 관계
  • 그 외

3. 모델링

• 'year', 'season', 'month', 'weekday', 'holiday'에 대해 가변수화 진행
• r2 score

holiday	season
DecisionTreeRegressor 7.004	DecisionTreeRegressor 7.356

year	month
DecisionTreeRegressor 7.201	DecisionTreeRegressor 6.931

딥러닝

⭐ 공공데이터로, 미세먼지 농도 예측 미션: 1시간 뒤의 미세먼지 농도 예측 머신러닝부터 딥러닝까지 여러 모델 적용하고 성능 향상

1. 데이터 분석 및 전처리

서울 지역의 미세먼지 데이터와 날씨 데이터를 전처리하고 머신러닝 모델 완성

• pd.to_datetime으로 날짜/시간 형식 데이터 타입 변환 및 merge
• 사용하지 않을 변수 제거
  • 도메인을 찾아보고, 데이터 소개를 보며 미세먼지와 관련있다고 여겨지는 컬럼만 남김
• 결측치 ffill(결측값을 바로 위 값과 동일하게 변경)로 처리
  • 1시간 단위로 측정된 시계열 데이터이고, 미세먼지와 날씨 데이터이므로 ffill로 채움
  • 처리하고 남은 결측치는 0으로 채움
• 모델링에 유용한 변수 추가
  • 전일 같은 시간(24시간 전) 미세먼지 농도 변수 추가
• target: t+1(1시간 후) 시점의 미세먼지 농도 변수

2. 모델링(머신러닝)

cv_score.mean()	r2_score
LinearRegression 0.9438	LinearRegression 0.93214

모델이 1시간 뒤의 값을 예측하는 데 있어 'PM10'이라는 변수의 중요성이 두드러지게 나타났다. 이 변수의 중요도가 특히 높아, 결국 이 값이 모델의 성능을 크게 좌우하는 결정적인 요소로 보인다.

🍚 맛집 추천

✔️ 카산도 정자본점

• 매일 11:00 - 22:00
• 경기 성남시 분당구 불정로71번길 2 1층
• 등심카츠정식 13,500원
• 안심카츠정식 14,500원

어쩌다가 먹으러 가게 된 돈까스!! 다들 경양식을 더 좋아하시나요, 일식을 더 좋아하시나요? 둘 다 좋아하는 편이지만, 전 일식을 좀 더 좋아한답니다..! 저는 냉모밀 정식을 먹었습니다! 사실 돈까스가 사이드로 나올 줄 알았는데, 새우 튀김이 나왔습니다! 다른 에이블러님 돈까스도 먹어봤는데, 와.. 돈까스나 새우튀김이나 모두 정말 바삭바삭하고 맛있습니다!! 다음 번에는 냉우동도 먹어보고 싶고, 돈까스 정식도 먹어보고 싶네요!

✔️ 화붐신간짬뽕 분당직영점

• 매일 11:00 - 21:00
• 경기 성남시 분당구 내정로7번길 15 1층
• 간짬뽕 10,000원
• 짜장면 5,500원

한 에이블러님이 엄청 좋아하신 중식당입니다! 제가 짜장면이 땡겨서 먹으러 가게 됐는데, 이름부터 짬뽕집이다 보니, 짜장면보다 짬뽕 맛집!입니다!! 짜장면은 그냥 짜장면과 트러플 짜장면이 있는데, 저는 다음 번에 트러플 짜장면을 먹어봐야겠어요! 뭐가 다를지 궁금하네요! 여기 간짬봉은 흔히 아는 짬뽕과는 확연히 다르고, 맛있다고 하니! 꼭 한 번 드시러 가보세요!

✔️ 평이담백뼈칼국수 분당정자점

• 매주 월요일 정기휴무
• 11:30 - 21:00
• 경기 성남시 분당구 불정로77번길 10 1층
• 뼈칼국수 11, 000
• 비빔 칼국수 10,000

다시 한 번 먹게된 뼈칼국수! 지난 번과 달리 이번에는 비빔 대신 뼈칼국수를 먹었습니다!! 다른 에이블러님과 반반 나눠 먹었는데, 저는 비빔국수에 한 표! 정확히는 두 음식을 나눠 먹는게 제일 좋은 거 같네요! 짬짜면처럼 반반은 안나올까요?ㅋㅋ 비빔은 다 먹으면 조금 물리는 감이 있고, 뼈칼국수는 심심한데 맛있는? 그런 느낌이라 둘 다 먹는게 조합이 엄청 맛있는 거 같아요! 또 땡기네요 ㅎㅎㅎ

• 최적의 회귀모델
  • 최선의 회귀모델은 전체 데이터의 오차 합이 최소가 되는 모델을 의미
  • 결국 오차 합이 최소가 되는 가중치 $w_1$와 편향$w_0$을 찾는 것을 의미

단순 회귀(Simple Regression)

• 독립변수 하나가 종속변수에 영향을 미치는 선형 회귀

• x값 하나만으로 y값을 설명할 수 있는 경우

• 회귀식: $\hat{y} = w_0 + w_1x_1$

• 독립변수의 최선의 가중치와(w_1)와 편향(w_0)을 찾음

• 모델 학습 후 회귀계수 확인 가능

  • coef_: 회귀계수(=가중치)
  • intercept_: 편향

다중 회귀(Multiple Regression)

• 여러 독립변수가 종속변수에 영향을 미치는 선형 회귀
• 𝑦 값을 설명하기 위해서는 여러 개의 𝑥 값이 필요한 경우
• 회귀식: $\hat{y} = w_0 + w_1x_1 + \cdots + w_nx_n$
• 각 독립변수의 최선의 가중치와$(w_1, w_2, \cdots)$와 편향$(w_0)$을 찾음
• 회귀계수가 여럿이므로 독립변수 이름과 같이 확인하는 것을 권고

모델 구현

• 회귀 모델에만 사용
• 알고리즘 함수: sklearn.linear_model.LinearRegression
• 성능평가 함수: sklearn.metrics.mean_absolute_error, sklearn.metrics.r2_score 등

📌 K-Nearest Neighbor

• k 근접 이웃(가장 가까운 이웃 k개)
• 학습용 데이터에서 k개의 최근접 이웃의 값을 찾아 그 값들로 새로운 값을 예측하는 알고리즘
• 회귀와 분류에 사용되는 간단한 지도학습 알고리즘
• 다른 알고리즘에 비해 이해는 쉬우나, 연산속도가 느림

Scaling

필요성: KNN은 거리 기반 알고리즘이다. k개의 가장 가까운 이웃을 선택한 다음 이러한 이웃을 기반으로 새 관측값에 대한 클래스(분류 문제의 경우)를 할당하거나 값(회귀 문제의 경우)을 예측한다. 이러한 거리 기반 알고리즘은 모두 변수 규모의 영향을 받는다. 알고리즘은 더 높은 크기의 변수 쪽으로 편향되어서는 안된다. 이 문제를 극복하기 위해 모든 변수를 동일한 규모로 축소할 수 있다.

대표적인 스케일링 방법

• 방법 1: 정규화(Normalization) 각 변수의 값이 0과 1사이 값이 됨 $ X_{norm} = \displaystyle {x - {x_{min}}\over{x_{max} - x_{min}}} $

• 방법 2: 표준화(Standardization) 각 변수의 평균이 0, 표준편차가 1이 됨 $ X_{z} = \displaystyle {x - {x_{mean}}\over{x_{std}}} $

• 평가용 데이터에도 학습용 데이터를 기준으로 스케일링을 수행!

• sklearn이 제공하는 함수를 사용 가능

  # 함수 불러오기
  from sklearn.preprocessing import MinMaxScaler
  # 정규화
  scaler = MinMaxScaler()
  scaler.fit(x_train)
  x_train = scaler.transform(x_train)
  x_test = scaler.transform(x_test)

회귀모델 구현

• 알고리즘 함수: sklearn.neighbors.KNeighborsRegressor
• 성능평가 함수: sklearn.metrics.mean_absolute_error, sklearn.metrics.r2_score 등

분류모델 구현

• 알고리즘 함수: sklearn.neighbors.KNeighborsClassifier
• 성능평가 함수: sklearn.metrics.confusion_matrix, sklearn.metrics.classification_report등

📌 Decision Tree

• 결정 트리, 의사 결정 나무
• 특정 변수에 대한 의사결정 규칙을 나무 가지가 뻗는 형태로 분류해 나감
• 분류와 회귀 모두에 사용되는 지도학습 알고리즘
• 훈련 데이터에 대한 제약 사항이 거의 없는 유연한 모델
  • 과적합으로 모델 성능이 떨어지기 쉬움
  • 트리 깊이를 제한하는(=가지치기) 튜닝이 필요

용어

• Root Node(뿌리마디): 전체 자료를 갖는 시작하는 마디
• Terminal Node(끝마디): 자식 마디가 없는 마디(= Leaf Node)
• Internal Node(중간 마디): 부모 마디와 자식 마디가 모두 있는 마디
• Branch(가지): 연결되어 있는 2개 이상의 마디 집합
• Depth(깊이): 뿌리 마디로부터 끝 마디까지 연결된 마디 개수

불순도(Impurity)

• 순도가 높을수록 분류가 잘 된 것

불순도를 수치화 할 수 있는 지표

지니 불순도

• $지니 불순도 = 1 - (양성 클래스 비율^2 + 음성 클래스 비율^2)$

$Gini = 1 - \sum_{i=1}^{c} {(pi)^2}$

• 분류 후에 얼마나 잘 분류했는지 평가하는 지표
• 특징
  • 지니 불순도가 낮을수록 순도가 높음
  • 지니 불순도응 0 ~ 0.5 사이의 값(이진 분류의 경우)
    • 순수하게 분류되면 → 0
    • 완벽하게 섞이면(50:50) → 0.5
  • 지니 불순도가 낮은 속성으로 의사결정 트리 노드 결정

엔트로피(Entropy)

• $엔트로피 = -음성클래스비율 \times \log_2(음성클래스비율) - 양성클래스비율 \times \log_2(양성클래스비율)$

$Entropy = -\sum_{i=1}^m {p_i \log_2 p_i}$

• p_i = 집합 안에서 속성 i의 확률을 나타냄
• 엔트로피는 0~1 사이의 값
  • 순수하게 분류되면 → 0
  • 완벽하게 섞이면(50:50) → 1

* 정보 이득(Information Gain)*

• 어떤 속성이 얼마나 많은 정보를 제공하는가
• 정보 이득 공식

$Gain(T, X) = Entropy(T) - Entropy(T, X)$

• 정보 이득이 크다 = 어떤 속성으로 분할할 때 불순도가 줄어든다
• 모든 속성에 대해 분할한 후 정보 이득 계산
• 정보 이득이 가장 큰 속성부터 분할

가지치기

• 가지치기 하지 않으면 과대적합, 일반화되지 못함

• 여러 하이퍼파라미터 값을 조정해 가지치기 가능

• 학습 데이터에 대한 성능은 낮아지나, 평가 데이터에 대한 성능을 높일 수 있음

• 적절한 하이퍼파라미터 값을 찾도록 노력

• 주요 하이퍼파라미터

  • max_depth: 트리의 최대 깊이(기본값: None)
  • min_samples_split: 노드를 분할하기 위한 최소한의 샘플 개수(기본값: 2)
  • min_samples_leaf: 리프 노드가 되기 위한 최소한의 샘플 수(기본값: 1)
  • max_feature: 최선의 분할을 위해 고려할 Feature 수(기본값: None)
  • max_leaf_node: 리프 노드 최대 개수

회귀모델 구현

• 알고리즘 함수: sklearn.tree.DecisionTreeRegressor
• 성능평가 함수: sklearn.metrics.mean_absolute_error, sklearn.metrics.r2_score 등

분류모델 구현

• 알고리즘 함수: sklearn.tree.DecisionTreeClassifier
• 성능평가 함수: sklearn.metrics.confusion_matrix, sklearn.metrics.classification_report등

📌 Logistic Regression

로지스틱 함수

• 시그모이드(sigmoid) 함수 $p = {1 \over 1 = e^{-f(x)}}$

• 확률 값 𝑝 는 선형 판별식 값이 커지면 1, 작아지면 0에 가까운 값이 됨

• ($-\infin$, $\infin$) 범위를 갖는 선형 판별식 결과로 $(0, 1)$ 범위의 확률 값을 얻게 됨

• 기본적으로 확률 값 0.5를 임계값(Threshold)로 하여 이보다 크면 1, 아니면 0으로 분류

분류모델 구현

• Logistic Regression 알고리즘은 분류모델에만 사용할 수 있음
• 알고리즘 함수: sklearn.linear_model.LogisticRegression
• 성능평가 함수: sklearn.metrics.confusion_matrix, sklearn.metrics.classification_report등

📌 K-Fold Cross Validation

• 모든 데이터가 평가에 한 번, 학습에 k-1번 사용
• K개의 분할(Fold)에 대한 성능을 예측 → 평균과 표준편차 계산 → 일반화 성능
• 단, k는 2 이상이 되어야 함(최소한 한 개씩의 학습용, 검증용 데이터가 필요)
• 모델 선언 후 cross_val_score(모델, x_train, y_train, 분할 개수) 형태로 사용
• 기본 분할 개수(cv) 값은 5이며, 필요에 따라 적절히 조절할 수 있음
• cross_val_score 함수 결과로 얻은 성능들의 평균을 모델의 성능으로 봄

📌 Hyperparameter 튜닝

• Hyperparameter
• Random Search, Grid Search

이 부분에 대해선 더 공부가 필요하다. 공부를 하면서 차차 추가해 보도록 하겠다.

지도학습

학습 대상이 되는 데이터에 정답을 주어 규칙성, 즉 데이터의 패턴을 배우게 하는 학습 방법

• 분류(Classification) - 범줏값을 예측
  • 이미 적절히 분류된 데이터를 학습하여 분류 규칙을 찾고, 그 규칙을 기반으로 새롭게 주어진 데이터를 적절히 분류하는 것을 목적으로 함
• 회귀(Regression) - 연속적인 숫자를 예측
  • 이미 결과값이 있는 데이터를 학습하여 입력 값과 결과 값의 연관성을 찾고, 그 연관성을 기반으로 새롭게 주어진 데이터에 대한 값을 예측하는 것을 목적으로 함

• 분류와 회귀는 서로 다른 함수를 사용해 모델링을 하게 됨

비지도학습

정답이 없는 데이터 만으로 배우게 하는 학습 방법

• 군집화(Clustering)
  • 주어진 데이터를 학습하여 적절한 분류 규칙을 찾아 데이터를 분류함을 목적으로 함. 정답이 없으니 성능을 평가하기도 어려움
• 변환(Transform)
• 연관(Association)

강화학습

선택한 결과에 대해 보상을 받아 행동을 개선하면서 배우게 하는 학습 방법

📌 회귀 모델 성능 평가

✔️ 회귀 평가 지표 정리

• MSE, Mean Squared Error 오차 제곱(SSE)의 합을 구한 후 평균을 구함 $MSE = \displaystyle {\sum{(y-\hat{y})^2} \over n}$

• RMSE, Root Mean Squared Error 오차의 제곱이므로 루트를 사용해 일반적인 값으로 표현 $RMSE = \displaystyle \sqrt{\sum{(y-\hat{y})^2} \over n}$

• MAE, Mean Absolute Error 오차 절댓값의 합을 구한 후 평균을 구함 $MAE = \displaystyle {\sum\vert{(y-\hat{y})^2\vert} \over n}$

• MAPE, Mean Absolute Percentage Error 오차 비율을 표시하고 싶은 경우 MAPE를 사용함 $MAPE = \displaystyle {{\sum{\vert{y-\hat{y}\over n}\vert} }\over n}$

✔️ 오차를 보는 다양한 관점

• SST, Sum Squared Total 전체 오차(최소한 평균 보다는 성능이 좋아야 하니, 우리에게 허용된 오차) $SST = \displaystyle {\sum_{i=1}^{n}{(y_i-\bar{y})^2}}$

• SSR, Sum squared Regression 전체 오차 중에서 회귀식이 잡아낸 오차 $SSR = \displaystyle {\sum_{i=1}^{n}{(\hat{y_i}-\bar{y})^2}}$

• SSE, Sum Squared Error 전체 오차 중에서 회귀식이 여전히 잡아내지 못한 오차 $SSE = \displaystyle {\sum_{i=1}^{n}{(y_i-\hat{y_i})^2}}$

• $SST=SSR+SSE$*

✔️ 결정계수 $R^2$ (R-Squared)

$R^2 = {{SSR} \over {SST}} = 1 - {SSE \over SST}$

• 모델 성능을 해석하기 위해서 만든 MSE의 표준화된 버전이 결정 계수임
• 전체 오차 중에서 회귀식이 잡아낸 오차 비율(일반적으로 0~1 사이)
• 오차의 비 또는 설명력이라고 부름
• $𝑅^2 = 1$이면 $𝑀𝑆𝐸 = 0$이고 모델이 데이터를 완벽하게 학습한 것

📌 분류 모델 성능 평가

✔️ 혼동행렬과 평가지표

• Confusion Matrix(오분류표) 사진출처

  

• TN(True Negative, 진음성) 음성으로 잘 예측한 것(음성을 음성이라고 예측한 것)

• FP(False Positive, 위양성) 양성으로 잘 못 예측한 것(음성을 양성이라고 예측한 것)

• FN(False Negative, 위음성) 음성으로 잘 못 예측한 것(양성을 음성이라고 예측한 것)

• TP(True Positive, 진양성) 양성으로 잘 예측한 것(양성을 양성이라고 예측한 것)

• 정확도(Accuracy) $$ (Accuracy) = \displaystyle {{TN + TP}\over{TN + FP + FN + TP}} $$

  • 전체 중에서 Positive와 Negative 로 정확히 예측한(TN + TP) 비율
  • 가장 직관적으로 모델 성능을 확인할 수 있는 평가지표

• 정밀도(Precision) $$ (Precision) = \displaystyle {{TP}\over{FP +TP}} $$

  • Positive로 예측한 것(FP + TP) 중에서 실제 Positive(TP)인 비율

• 재현율(Recall) $$ (Recall) = \displaystyle {{TP}\over{FN +TP}} $$

  • 실제 Positive(FN + TP) 중에서 Positive로 예측한(TP) 비율
  • 민감도(Sensitivity)라고 부르는 경우가 많음

• 특이도(Specificity) $$ (Specificity) = \displaystyle {{TN}\over{TN +FP}} $$

  • 실제 Negative(TN + FP) 중에서 Negative로 예측한(TN) 비율

• F1-Score $$ (F1-Score) = \displaystyle {{2 \times {Precision} \times {Recall}}\over{{Precision} + {Recall}}} $$

  • 정밀도와 재현율의 조화 평균
  • 분자가 같지만 분모가 다를 경우, 즉 관점이 다른 경우 조화 평균이 큰 의미를 가짐

⭐ 서울시, 생활 정보 기반 대중 교통 수요 분석

미션: 버스 노선 추가가 필요한 서울시 내 자치구 선정

데이터 셋

• 구별 버스 정류장 분석
• 구별 이동인구 분석
• 구별 등록인구 분석
• 구별 업종 분석

이렇게 총 네 개의 데이터가 주어졌고, 5개의 가설을 수립하였다.

• 가설 1 : X = 자치구 → Y= 전체인구대비 버스이용승객비율
• 가설 2 : X = 자치구 → Y = 총 버스이용 승객 수 대비 정류장의 개수
• 가설 3 : X = 자치구 → Y = 정류장 대비 노선의 개수
• 가설 4 : X: 주점 종사자수 → Y: 정류장 수
• 가설 5 : X: 유출(출발) 인구 → Y: 정류장(노선)의 개수

첫 미니 프로젝트..! 첫날에는 개인으로 데이터를 처리하는 것이 대부분이었다. 우리 조원분들은 다들 뚝딱뚝딱 잘 해나가셔서, 따라잡기 급급했다! 좀 더 복습할 걸이라는 후회도 했다... 집 가서 마자 분석까지 다하고 자야지!라고 생각했지만 집에서 분당까지 왕복으로 거의 2시간 반에서 3시간.. 집 가자마자 뻗어버렸다.. 둘째 날부터 본격적으로 분석에 들어갔다. 사실 첫날에 데이터 처리할 때부터 어떤 시각으로 바라보고 어떻게 처리하고, 생각이 너무 많았다. 어떻게 해야 할지 감도 안 잡혔다. 조원분들이랑 가설 정하는 데 오랜 시간이 걸렸다. 강사님께 여쭤보니 우리가 너무 딥하게 생각했던 거 같다. 덕분에 다시 금방 간단하게 세우고 분석을 시작했다. 그만큼 너무 부족한 시간!! 분석하는데 시간이 부족한 만큼 PPT도 거의 못 만들었다. 잘 해보고 싶은데.. 이 부분은 조금씩 조금씩 내가 복습하면서 위에 가설을 바탕으로 다시 분석해 보고자 한다. 앞으로 조금씩 조금씩 수정해 보겠습니다!! ㅎㅎ

⭐ 서울시, 따릉이 수요 분석

따릉이에 대한 도메인 이해

• 기름값이 증가하면서 출퇴근 시간대에 따릉이 이용량이 증가
• 그만큼 적자가 생기면서 요금 인상 가능성이 생김

데이터 셋

• 서울시 공공자전거 이용정보 (시간대별)
• 해당 시점의 날씨 자료

가설 수립

• 가설 1 : X = 대여 시작 시간 → Y = 따릉이 대여량
• 가설 2 : X: 온도 (14 ~ 24도) -> Y: 따릉이 대여량
• 가설 3 : X: 미세먼지 -> Y: 따릉이 대여량
• 가설 4 : X: 습도-> Y: 따릉이 대여량

가설1: 출퇴근 시간대에 따릉이 대여량이 높을 것이다.

• 상관계수: 0.586
• P-value: 0.0 → 0이 나올 수 없으나 상관계수가 0.5에 가깝기 때문에 유의하다고 판단
• 대립가설 성립 → 시간대와 따릉이 대여량 간의 강한 관계가 존재
• 출근 시간대는 따릉이 전체 이용자 중 약 12%로 생각보다 저조하다.
• 퇴근 시간대는 따릉이 전체 이용자 중 35%로 대여량이 높다.

가설2: 선선한 날씨에 따릉이 대여량이 높을 것이다.

* 상관계수: 0.277
* P-value: 2.94𝑒^(−103)
* 대립가설 성립 → 온도와 따릉이 대여량 간의 관계가 존재
* 생각했던 선선한 날씨보다 24도가 넘는 더운 날에 따릉이 대여량이 더 높다.
* 폭염 기준인 33도를 넘는 날은 약 1.46%로 폭염에는 따릉이 대여량이 현저히 적다.

전 날 프로젝트 하면서 한 번 경험이 있어서 그런가, 이번에는 비교적 빠르게 서로 의견을 내며 진행이 되었다. 주어진 내용으로만 가설을 세우기에는 부족하다고 판단해서, 우리는 좀 더 세부적으로 세우고자 했다. 가설 하나하나마다 서로 토론하고 분석하고 의미를 찾다 보니 시간이 좀 오래 걸린 듯하다. 팀 프로젝트다 보니 분업도 중요하다고 많이 느꼈다. 강사님과 매니저님 두 분 모두 우리 조 분위기 좋고 잘 진행하고 있다고 하셔서 기분이 너무 좋았다. 발표도 하고 싶었지만 결국에 가설 두 번째 거까지만 진행하고 시간이 부족해서 발표를 못했다. 자꾸 매번 시간이 부족한 부분이 너무 아쉽다!! 다음번에는 더 잘해보고 싶다는 마음이 점점 더 커진다! 이 부분도 앞에 거부터 차근차근하다 보면 금방 정리하겠죠?ㅎㅎ

🍚 맛집 추천

✔️ 함흥미식관

• 매일 11:00 - 21:00
• 경기 성남시 분당구 불정로77번길 15 1층
• 물.비빔냉면 11,000

여름이 끝나가는 무렵 먹고싶던 냉면!! 냉면 먹으러 가는거 어떻냐고 여쭤봤더니, 다들 흔쾌히 가자고 해주셔서 감사합니다 ㅎㅎ 사진은 같은 조 팀원분께서...!! 감사합니당 ㅎㅎ KT본사 근처 냉면 맛집이라고 해서 가봤는데, 진짜로 맛있습니다! 오랜만에 냉면 한그릇 뚝딱!! 하지만 저에겐 양이 조금 부족했습니다 ㅠㅠ 사리 추가가 있던데, 했어야 했어요... 냉면 좋아하는 분들은 사리 추가! 하시는 걸로 ㅎ

✔️ 평이담백뼈칼국수 분당정자점

• 매주 월요일 정기휴무
• 11:30 - 21:00
• 경기 성남시 분당구 불정로77번길 10 1층
• 뼈칼국수 11, 000
• 비빔 칼국수 10,000

여기는 분당 매니저님이 추천해주신 뼈칼국수집!! 추천해주신만큼 저엉말 맛있고 배부르게 먹었습니다...!! 저는 비빔칼국수 먹었는데, 다음 번에는 뼈칼국수 먹으려고요 ㅋㅋㅋㅋ 뼈칼국수는 사골 육수..?에 감자탕집 뼈..?인데 와..맛있습니다!! 고기도 많고요 ㅋㅋㅋㅋ 다들 엄청 배불러 하셨어요! 저도 엄청 배 빵빵!! 다른 맛집도 추천해주셨는데, 기억이 잘 안나네요.. 다시 여쭤보고, 다른 집도 가보겠습니다 ㅎㅎ

❗마무리

음.. 사진이 은근히 마음대로 돌아가네요? 조정해야 하지만, 지금 너무 피곤한 관계로, 그냥 넘어가도록 하겠습니다! 처음으로 같은 조로 첫 미니 프로젝트를 3일 내내 함께하다 보니 엄청 정든 거 같아요! 다들 그러시죠..? 제 블로그 보실 거... 같은데.. 아닌가요...?ㅋㅋㅋㅋㅋㅋㅋ 15조 막내.. 여러분 덕분에 많이 배우고 즐거웠습니다! 감사합니다!! ( _ _ ) 맛있는 거 많이 먹고 볼링도 쳤습니다! 볼링!!! 잘 칠 줄 알았는데!!! 역대급으로 못 쳤네요... 다음번에는 잘 치고 싶습니다... 다음번에 꼭!! 한강에서 봬요😊

• columns 속성 변경: 모든 열 이름 변경
• rename() 메소드 사용: 지정한 열 이름 변경
  • 이때. inplace = True는 진짜로 수정하라는 말.

.rename(columns = {key: value}, inplace = True)

열 추가

• 맨 뒤에 열 추가
• 지정한 위치에 열 추가

열 삭제

• drop() 메소드를 사용해 열 삭제
  • axis = 0: 행 삭제(기본값)
  • axis = 1: 열 삭제
  • inplace = False: 삭제한 것 처럼 보이게 하는 것
  • inplace = True: 진짜로 삭제

📌 데이터프레임 결합

pd.concat()

• 매핑기준: 인덱스(행), 칼럼이름(열)

• 방향: axis = 0
  • 세로 (행)로 합치기(위, 아래로 붙여라 / 행 방향으로 붙여라!)
  • 칼럼 이름 기준
• 방향: axis = 1
  • 가로 (열)로 합치기 (옆으로 붙여라)
  • 행 인덱스 기준

• 방법 join
  • 'outer': 모든 행과 열 합치기(기본값)
  • 'inner': 같은 행과 열 합치기

pd.merge()

• 매핑기준: 특정 칼럼(key)의 값 기준으로 결합
• 데이터베이스 테이블 조인과 같다.
• 지정한 칼럼의 값을 기준으로 병합
  • 옆으로만 병합
  • 어떤 칼럼을 기준 삼을 것인가?
  • 방법 how
    • inner: 같은 값만
    • outer: 모두
    • left: 왼쪽 df는 모두, 오른쪽 df는 같은 값만
    • right: 오른쪽 df는 모두, 왼쪽 df는 같은 값만

pd.pivot

• pivot 함수를 이용하여 집계된 데이터를 재구성할 수 있다.
• 문법: dataframe.pivot(index, column, values)

📌 시계열 데이터

• 행과 행에 시간의 순서(흐름)가 있고
• 행과 행의 시간간격이 동일한 데이터

날짜 요소 뽑기

• 날짜 타입의 변수로부터 날짜의 요소를 뽑아낼 수 있다.
• .dt.날짜요소

시간에 따른 흐름 추출하기: Time Lag

• .shift()
  • 시계열 데이터에서 시간의 흐름 전후로 정보를 이동시킬 때 사용

시간에 따른 흐름 추출하기: Moving Average

• .rolling().mean()

  * 시간의 흐름에 따라 일정 기간 동안 평균을 이동하면서 구하기

시간에 따른 흐름 추출하기: 차분

• .diff()
  • 특정 시점 데이터, 이전시점 데이터와의 차이 구하기

📌 시각화 라이브러리

데이터의 시각화

• 수 많은 데이터를 한 눈에 파악하는 두 가지 방법
• Focus
  • 우리가 다루는 데이터에는 비지니스가 담겨 있다
  • 데이터 시각화의 목적은
    • 아름다운 그래프가 아니라, 통계적인 해석을 넘어, 비지니스의 인사이트를 파악하는 것이다.
• 한계
  • 그래프와 통계량에섯 요약된 정보(원본)가 표현된다.
  • 요약을 하는 관점에 따라 해석의 결과가 달라질 수 있다.
  • 어떤 식으로든 요약을 하면, 정보의 손실이 발생된다.

기본 코드 구조

• 라이브러리: matplotlib.pyplot
• plt.plot()
  • 기본 라인차트를 그려준다.
  • plt.plot(x, y)
  • plt.plot(x, y, data)
• plt.show()
  • 그래프를 화면에 출력해 준다.

부가적인

• plt.xticks(rotation=각도) : x축 값 조정하기
• plt.xlabel(), plt.ylabel(): 축 레이블 추가
• plt.title(): 그래프 제목(타이틀) 추가
• 이 외에도 색, 라인 스타일, 마커 등을 바꿀 수 있다.

📌 단변량 분석 - 숫자형

• df.describe()
  • 데이터 프레임의 숫자형 변수들에 대해서 기초 통계량을 구함.

숫자형 변수 시각화하기

• 기초 통계량(basic statistics)
  • Box Plot:
    • plt.boxplot()
    • 사전에 반드시 NaN 제외
    • sns.boxplot은 NaN을 알아서 제거해 줌
• 도수분포표(frequency table)
  • Histogram:
    • plt.hist(변수명, bins = 구간 수)
  • Density Plot (KDE Plot):
    • sns.kdeplot(변수명)

📌 단변량 분석 - 범주형

• 범주별 빈도수
  • 시리즈.value_counts()

범주형 변수 시각화: Bar Plot

• sns.countplot
  • 범주별 빈도수를 계산하고 bar plot으로 나타냄
• plt.bar
  • 범주별 빈도수를 직접 계산한 결과 입력 시 범주별 빈도 bar plot 생성

❗마치며..

데이터를 분석하기 전에 어떻게 처리해야 하는지에 대해 배웠다.. 아직 손에 익숙하지도 않고 이렇게 처리한 데이터를 어떻게 분석해야 할지 감도 잘 안 오지만, 다음 번 포스팅에는 종합 문제를 통해 단변량, 이변량 분석을 통해 어떻게 분석하고 의미를 찾아내야 하는지 복습하면서 정리해 보고자 한다. 곧 미니 프로젝트인데 걱정 반, 기대 반..

pandas는 데이터 조작 및 분석을 위한 파이썬 프로그래밍 언어 용으로 작성된 소프트웨어 라이브러리이다. 숫자 테이블과 시계열을 조작하기 위한 데이터 구조와 연산을 제공하며, 무료 소프트웨어 New BSD 라이센스이다. -위키백과

데이터프레임(DataFrame)

• Series
  • 하나의 정보에 대한 데이터들의 집합
  • DataFrame의 단일 열에 대한 데이터 구조(1차원)
• 데이터 분석에서 가장 중요한 데이터 구조
• 관계형 데이터베이스의 테이블 또는 엑셀 시트와 같은 형태
• Series들을 하나의 열로 취급한 집합

📌 라이브러리 불러오기

import pandas as pd

📌 딕셔너리로 만들기

데이터프레임 직접 만들기

• pd.DataFrame() 함수를 사용해 데이터프레임을 직접 만들 수 있다.
• 대부분 리스트, 딕셔너리, Numpy 배열로부터 데이터프레임을 만든다.

# 딕셔너리
dict1 = {'Name': ['Gildong', 'Sarang', 'Jiemae', 'Yeoin'],
        'Level': ['Gold', 'Bronze', 'Silver', 'Gold'],
        'Score': [56000, 23000, 44000, 52000]}
df = pd.DataFrame(dict)

# 리스트
frame = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

📌 CSV파일 읽어오기

path = 'https://raw.githubusercontent.com/DA4BAM/dataset/master/titanic_simple.csv'
data = pd.read_csv(path) 

📌 데이터프레임 정보 확인

• head 메소드: 상위 데이터 확인 (기본값 5개)
• tail 메소드: 하위 데이터 확인 (기본값 5개)
• shape 속성: 크기 확인 → (행수, 열수) 형태

data.head(3)    # 상위 3개
data.tail(10)    # 하위 10개
data.shape        # (891, 8)

📌 열, 행 정보 보기

• values: 값 정보 확인(저장하면 2차원 numpy 배열이 됨)
• columns: 열 정보 확인

  data.columns
  # Index(['PassengerId', 'Survived', 'Pclass', 'Name', 'Sex', 'Age', 'Fare','Embarked'], dtype='object')
  

data.columns.values # np.array 형태

데이터프레임을 리스트 함수에 넣으면 열 이름이 리스트로 반환됨

list(data)

* <mark>dtypes</mark>: 열 자료형 확인
  * int64: 정수형 데이터(int)
  * float64: 실수형 데이터(float)
  * object: 문자열 데이터(string)
* <mark>info</mark>: 인덱스, 열, 값 개수, 데이터 형식 정보 등 확인
* <mark>describe</mark>: 기초 통계 정보 확인(count, mean, std, mi, 25%, 50%, 75%, max)

### 📌 데이터 정렬
* <mark>sort_index</mark> 메소드로 인덱스를 기준으로 정렬
* <mark>sort_values</mark> 메소드로 특정 열을 기준으로 정렬
* 정렬 방법
  * ascending = True: 오름차순 정렬(기본값)
  * ascending = False: 내림차순 정렬
```python
# 내림차순 정렬
data.sort_index(ascending = False)

# Age 열을 기준으로 내림차순 정렬
data.sort_values(by = 'Age', ascending = False)

# 복합 열 정렬
data.sort_values(by = ['Age', 'Pclass'], ascending = [True, False])

📌 기본 집계

✔️고유 값 확인

• unique() 메소드: 고유 값 확인
• value_counts() 메소드: 고유 값과 그 개수 확인

  print(data['Embarked'].unique())    # ['Southampton' 'Cherbourg' 'Queenstown' nan]
  

print(data['Embarked'].value_counts())

Southampton 644

Cherbourg 168

Queenstown 77

Name: Embarked, dtype: int64

#### ✔️기본 집계 메소드
* <mark>sum()</mark>: 합
* <mark>mean()</mark>: 평균
* <mark>max()</mark>: 최댓값
* <mark>min()</mark>: 최솟값
* <mark>count()</mark>: 개수
```python
data['Age'].sum()    # 21205.17

# Age, Fare 두 열의 최댓값을 한 번에 확인
data[['Age', 'Fare']].max()
# Age      80.0000
# Fare    512.3292
# dtype: float64

📌 특정 열 조회

• 1차원(시리즈)로 조회
  • DataFrame['column']
  • DataFrame.column
• 2차원(데이터프레임)으로 조회
  • 칼럼 이름을 리스트로 입력할 것!
  • DataFrame[['column']]

    # 1차원 조회
    data['Age']
    data.Age
    

2차원 조회

data[['Age']] data[['Age', 'Pclass']] # Age, Pclass 열만 조회

Age, Pclass열만 Age 열 기준으로 내림차순 정렬해서 조회

data[['Age', 'Pclass']].sort_values(by = 'Age', ascending = False)

* 조건으로 조회: **.loc[행 조건, 열 이름]**
  * 행 조건: 조건문 형태 → 조건에 만족하는 데이터만 조회
  * 열 이름
    * 생략 가능
    * 열 이름 1개 → 결과: 시리즈
    * 열 이름(여러 개)을 리스트로 → 결과: 데이터프레임
  * isin(), between() 메소드
    * <mark>isin([값1, ..., 값n])</mark>: 값1 또는 ... 값n인 데이터만 조회
    * <mark>between(n, m)</mark>: n~m까지 범위 안의 데이터만 조회
```python
# 단일 조건 조회
data.loc[data['Age']>=70]

# 여러 조건 조회
data.loc[data['Age']>= 70 & data['Pclass'] == 2)]

# 조건을 만족하는 행의 일부 열 조회
data.loc[data['Age'] >= 30, ['Pclass', 'Sex']]

# isit() 메소드
data.loc[data['Embarked'].isin(['Southhampton', 'Queenstown'])]

# between() 메소드
data.loc[data['Age'].between(10, 20, inclusive='left') & (data['Sex'] == 'male')]

📌 groupby()

DataFrame.groupby('집계기준변수', as_index=)['집계대상변수'].집계함수

• as_index = True: 집계기준변수를 인덱스로 사용
• as_index = False: 집계기준변수를 인덱스가 아닌 열로 사용 → 행 번호를 기반으로 한 정수 값이 인덱스로 설정

• [['data']].sum()과 같이 하면 열이 여럿이라는 의미여서 결과가 데이터프레임이 됨
• 여러 열 집계
  • [ ['feature1', 'feature2'] ].sum() 형태와 같이 집계 대상 열을 리스트로 지정
• by=['feature1', 'feature2'] 과 같이 집계 기준 열을 여럿 설정 가능

# Embarked 별 Fare 평균 → 시리즈
data.groupby('Embarked', as_index = False)['Fare'].mean()

# 여러열 집계
# Embarked, Sex 별 Fare 평균과 Age 평균 → 데이터프레임
data.groupby(['Embarked','Sex'], as_index = False)[['Fare','Age']].mean()

# sum() 메소드 앞에 아무 열도 지정하지 않으면 기준열 이외의 모든 열에 대한 집계가 수행
# Embarked 열 이외의 모든 열에 대한 집계가 수행
data.groupby('Embarked', as_index=False).sum()

✔️agg()메소드: .agg()

• 열 하나에 대해 합계, 평균 등의 집계를 한 번에 수행 가능
• 여러 열에 대해 여러 집계를 한 번에 수행 가능
• 집계 대상 열과 집계 방법을 리스트 형태로 지정

  # 객실등급(Pclass)별, 생존여부(Survived)별 나이(Age), 운임(Fare)의 최대, 최소, 평균, 표준편차
  data.groupby(['Pclass','Survived'], as_index = False)[['Age','Fare']].agg(['max', 'min', 'mean', 'std'])